rediseed 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 authoritydmc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,165 @@
+# ⚡ rediseed (`seedx` / `redisx`)
+
+> **Blazing-fast Redis data seeder & loader from CSV, JSON, and line streams.**  
+> Built for k6 performance testing, unique token popping (`SPOP`), queue fixture populating, and instant Redis inspection.
+
+[![npm version](https://img.shields.io/npm/v/rediseed.svg?style=flat-square&color=cb3837)](https://www.npmjs.com/package/rediseed)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+
+---
+
+## 🚀 Key Features
+
+- 🏎️ **High Throughput**: Pipelined batch insertion processing 100k+ records/sec.
+- 🎯 **Load-Testing Ready (k6 / Locust / JMeter)**: Pre-seed test users, auth tokens, or session IDs into Redis Sets for collision-free `SPOP` or `SRANDMEMBER` consumption.
+- 📁 **Universal Input Formats**: Auto-detects and loads **CSV**, **TSV**, **JSON arrays**, **JSONL / NDJSON**, and plaintext line streams.
+- 🗄️ **All Redis Structures Supported**:
+  - **Sets (`SADD`)**: Collision-free unique user/token pools.
+  - **Lists (`RPUSH` / `LPUSH`)**: FIFO order queues & worker queues.
+  - **Hashes (`HSET`)**: Structured records indexed by primary key column.
+  - **Sorted Sets (`ZADD`)**: Prioritized or timestamp-ordered items.
+  - **String Keys (`SET`)**: Individual key-values with optional TTL expiration.
+- 🧩 **Dynamic Key & Value Templating**: Define schema patterns like `--key "user:{{tenant_id}}:{{user_id}}"` or `--value "{{email}}:{{token}}"`.
+- 🔍 **Inspect & Verify**: Check key data types, card/lengths, memory usage, and preview sample items in the terminal.
+- 📝 **k6 Snippet Generator**: Instantly generate ready-to-run `xk6-redis` load testing scripts.
+
+---
+
+## 📦 Installation
+
+Run instantly via `npx` or install globally:
+
+```bash
+# Run directly with npx
+npx rediseed --help
+npx seedx --help
+npx redisx --help
+
+# Or install globally
+npm install -g rediseed
+```
+
+---
+
+## ⚡ Quick Usage Examples
+
+### 1. 🎯 Load Test User Tokens into a Redis Set (for k6 `SPOP`)
+
+Given a `users.csv` file:
+```csv
+id,username,token
+1,alice,tok_live_948172
+2,bob,tok_live_109283
+3,charlie,tok_live_771920
+```
+
+Load all tokens into a Redis set `k6:auth_tokens`:
+```bash
+# Using the shortcut set command
+seedx set k6:auth_tokens users.csv --column token --flush
+
+# Or with custom Redis URL
+seedx set k6:auth_tokens users.csv --column token --url redis://:password@10.0.0.1:6379/0
+```
+
+---
+
+### 2. 🧩 Seed Hash Records with Dynamic Key Templating
+
+Seed each row as an individual Redis Hash keyed by user ID:
+```bash
+seedx seed users.csv --structure hash --key "app:users:{{id}}" --flush
+```
+
+---
+
+### 3. 🔍 Inspect Seeded Redis Keys
+
+Verify the count, data type, memory footprint, and preview sample items:
+```bash
+seedx inspect k6:auth_tokens
+```
+
+Output:
+```text
+🔍 Redis Key Inspector
+  • Key: k6:auth_tokens
+  • Type: SET
+  • Total Items: 50,000
+  • TTL: No Expiration
+  • Memory Usage: 412.50 KB
+
+Sample Items:
+  • tok_live_948172
+  • tok_live_109283
+  • tok_live_771920
+```
+
+---
+
+### 4. 📝 Generate k6 Load Test Script
+
+Generate a ready-to-run k6 test script consuming the seeded tokens via `xk6-redis`:
+```bash
+seedx k6 k6:auth_tokens --structure set
+```
+
+Output:
+```javascript
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+import redis from 'k6/x/redis';
+
+const client = new redis.Client('redis://localhost:6379');
+
+export const options = {
+  vus: 50,
+  duration: '1m',
+};
+
+export default function () {
+  // Pop unique token (guarantees NO collision between VUs)
+  const uniqueToken = client.spop('k6:auth_tokens');
+
+  if (!uniqueToken) {
+    console.warn('Tokens exhausted!');
+    return;
+  }
+
+  const res = http.get('https://api.example.com/v1/profile', {
+    headers: { Authorization: `Bearer ${uniqueToken}` },
+  });
+
+  check(res, { 'status is 200': (r) => r.status === 200 });
+  sleep(0.1);
+}
+```
+
+---
+
+## 🛠️ CLI Options Reference
+
+```text
+Usage: rediseed [options] [command]
+
+Options:
+  -v, --version               Output current version
+  -u, --url <url>             Redis connection URL (redis:// or rediss://)
+  -h, --host <host>           Redis host (default: "127.0.0.1")
+  -p, --port <port>           Redis port (default: "6379")
+  -a, --password <password>   Redis password
+  -n, --db <db>               Redis database index (0-15)
+  --tls                       Enable TLS connection
+
+Commands:
+  seed [options] <file>       Seed CSV, JSON, or line file into Redis
+  set [options] <key> <file>  Shortcut to load column into Redis Set
+  inspect [options] <key>     Inspect type, item count, memory & samples
+  k6 [options] <key>          Generate ready-to-run k6 test script
+```
+
+---
+
+## 🛡️ License
+
+MIT © [authoritydmc](https://github.com/authoritydmc)

package/dist/cli.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,463 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+var import_picocolors = __toESM(require("picocolors"));
+
+// src/loaders/file.ts
+var import_fs = __toESM(require("fs"));
+var import_sync = require("csv-parse/sync");
+function parseCSV(content, delimiter = ",") {
+  const records = (0, import_sync.parse)(content, {
+    columns: true,
+    skip_empty_lines: true,
+    trim: true,
+    delimiter,
+    cast: false
+  });
+  return records;
+}
+function parseJSONOrJSONL(content) {
+  const trimmed = content.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    const parsed = JSON.parse(trimmed);
+    if (!Array.isArray(parsed)) throw new Error("JSON root must be an array of objects.");
+    return parsed;
+  }
+  const lines = trimmed.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  const rows = [];
+  for (const line of lines) {
+    if (line.startsWith("{") && line.endsWith("}")) {
+      rows.push(JSON.parse(line));
+    } else {
+      rows.push({ value: line });
+    }
+  }
+  return rows;
+}
+function parseLines(content) {
+  return content.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).map((l) => ({ value: l }));
+}
+function loadAndParseFile(filePath) {
+  if (!import_fs.default.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const content = import_fs.default.readFileSync(filePath, "utf8");
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  if (ext === "csv") {
+    return parseCSV(content);
+  } else if (ext === "tsv") {
+    return parseCSV(content, "	");
+  } else if (ext === "json" || ext === "jsonl" || ext === "ndjson") {
+    return parseJSONOrJSONL(content);
+  } else if (ext === "txt") {
+    return parseLines(content);
+  }
+  try {
+    return parseJSONOrJSONL(content);
+  } catch {
+    try {
+      return parseCSV(content);
+    } catch {
+      return parseLines(content);
+    }
+  }
+}
+
+// src/engine/client.ts
+var import_ioredis = require("ioredis");
+function createRedisClient(options = {}) {
+  const url = options.url || process.env.REDIS_URL || process.env.REDIS_URI;
+  if (url) {
+    return new import_ioredis.Redis(url, {
+      lazyConnect: false,
+      maxRetriesPerRequest: 3,
+      enableReadyCheck: true
+    });
+  }
+  const redisConfig = {
+    host: options.host || process.env.REDIS_HOST || "127.0.0.1",
+    port: options.port || (process.env.REDIS_PORT ? parseInt(process.env.REDIS_PORT, 10) : 6379),
+    password: options.password || process.env.REDIS_PASSWORD || void 0,
+    db: options.db !== void 0 ? options.db : process.env.REDIS_DB ? parseInt(process.env.REDIS_DB, 10) : 0,
+    maxRetriesPerRequest: 3,
+    lazyConnect: false
+  };
+  if (options.tls) {
+    redisConfig.tls = {};
+  }
+  return new import_ioredis.Redis(redisConfig);
+}
+
+// src/utils/template.ts
+function renderTemplate(template, row) {
+  return template.replace(/\{\{\s*([a-zA-Z0-9_-]+)\s*\}\}/g, (_, key) => {
+    return row[key] !== void 0 ? String(row[key]) : "";
+  });
+}
+function extractRowValue(row, column, valueTemplate) {
+  if (valueTemplate) {
+    return renderTemplate(valueTemplate, row);
+  }
+  if (column && row[column] !== void 0) {
+    return String(row[column]);
+  }
+  const keys = Object.keys(row);
+  if (keys.length === 1) {
+    return String(row[keys[0]]);
+  }
+  return JSON.stringify(row);
+}
+
+// src/engine/seeder.ts
+async function executeSeed(redis, rows, options) {
+  const startTime = Date.now();
+  const batchSize = options.batchSize || 1e3;
+  let totalInserted = 0;
+  const uniqueKeys = /* @__PURE__ */ new Set();
+  if (options.flushFirst && options.keyName && !options.keyName.includes("{{")) {
+    await redis.del(options.keyName);
+  }
+  for (let i = 0; i < rows.length; i += batchSize) {
+    const batch = rows.slice(i, i + batchSize);
+    const pipeline = redis.pipeline();
+    for (const row of batch) {
+      const targetKey = options.keyName ? renderTemplate(options.keyName, row) : "seed:data";
+      uniqueKeys.add(targetKey);
+      const val = extractRowValue(row, options.column, options.valueTemplate);
+      switch (options.structure) {
+        case "set":
+          pipeline.sadd(targetKey, val);
+          break;
+        case "list":
+          pipeline.rpush(targetKey, val);
+          break;
+        case "string":
+          if (options.ttl) {
+            pipeline.set(targetKey, val, "EX", options.ttl);
+          } else {
+            pipeline.set(targetKey, val);
+          }
+          break;
+        case "hash":
+          const hashFields = {};
+          for (const [k, v] of Object.entries(row)) {
+            hashFields[k] = typeof v === "object" ? JSON.stringify(v) : String(v);
+          }
+          pipeline.hset(targetKey, hashFields);
+          if (options.ttl) {
+            pipeline.expire(targetKey, options.ttl);
+          }
+          break;
+        case "zset":
+          const score = options.scoreColumn && row[options.scoreColumn] !== void 0 ? parseFloat(row[options.scoreColumn]) || 0 : Date.now();
+          pipeline.zadd(targetKey, score, val);
+          break;
+      }
+    }
+    await pipeline.exec();
+    totalInserted += batch.length;
+  }
+  const elapsedMs = Math.max(1, Date.now() - startTime);
+  const opsPerSec = Math.round(totalInserted / elapsedMs * 1e3);
+  return {
+    totalProcessed: rows.length,
+    totalInserted,
+    elapsedMs,
+    opsPerSec,
+    structure: options.structure,
+    keysAffected: uniqueKeys.size
+  };
+}
+
+// src/engine/inspector.ts
+async function inspectKey(redis, key, sampleCount = 5) {
+  const [type, ttl] = await Promise.all([
+    redis.type(key),
+    redis.ttl(key)
+  ]);
+  let count = 0;
+  let samples = [];
+  switch (type) {
+    case "set":
+      count = await redis.scard(key);
+      samples = await redis.srandmember(key, sampleCount) || [];
+      break;
+    case "list":
+      count = await redis.llen(key);
+      samples = await redis.lrange(key, 0, sampleCount - 1) || [];
+      break;
+    case "hash":
+      count = await redis.hlen(key);
+      const hashData = await redis.hgetall(key);
+      samples = Object.entries(hashData).slice(0, sampleCount).map(([k, v]) => `${k}: ${v}`);
+      break;
+    case "zset":
+      count = await redis.zcard(key);
+      samples = await redis.zrange(key, 0, sampleCount - 1) || [];
+      break;
+    case "string":
+      count = 1;
+      const val = await redis.get(key);
+      samples = val ? [val] : [];
+      break;
+  }
+  let memoryBytes;
+  try {
+    const memory = await redis.memory("USAGE", key);
+    if (typeof memory === "number") memoryBytes = memory;
+  } catch {
+  }
+  return {
+    key,
+    type,
+    count,
+    memoryBytes,
+    ttl,
+    samples
+  };
+}
+
+// src/utils/k6.ts
+function generateK6Snippet(keyName, structure) {
+  if (structure === "set") {
+    return `// ==========================================
+// k6 Load Test - Redis Set Data Consumption
+// Requirements: xk6-redis (k6 run --vus 50 --duration 1m script.js)
+// ==========================================
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+import redis from 'k6/x/redis';
+
+// Connect to Redis
+const client = new redis.Client('redis://localhost:6379');
+
+export const options = {
+  vus: 50,
+  duration: '1m',
+};
+
+export default function () {
+  // Option A: Pop unique token (guarantees NO collision between VUs)
+  const uniqueToken = client.spop('${keyName}');
+
+  // Option B: Random sample (if token is reusable across VUs)
+  // const uniqueToken = client.srandmember('${keyName}');
+
+  if (!uniqueToken) {
+    console.warn('Redis set "${keyName}" is exhausted!');
+    return;
+  }
+
+  // Execute authenticated HTTP request using seeded token
+  const res = http.get('https://api.example.com/v1/user/profile', {
+    headers: {
+      Authorization: \`Bearer \${uniqueToken}\`,
+    },
+  });
+
+  check(res, {
+    'status is 200': (r) => r.status === 200,
+  });
+
+  sleep(0.1);
+}
+`;
+  }
+  if (structure === "list") {
+    return `// ==========================================
+// k6 Load Test - Redis Queue / List FIFO
+// Requirements: xk6-redis
+// ==========================================
+import http from 'k6/http';
+import { check } from 'k6';
+import redis from 'k6/x/redis';
+
+const client = new redis.Client('redis://localhost:6379');
+
+export default function () {
+  // Pop from FIFO queue
+  const item = client.lpop('${keyName}');
+
+  if (!item) {
+    console.warn('Queue "${keyName}" is empty!');
+    return;
+  }
+
+  const payload = JSON.parse(item);
+  const res = http.post('https://api.example.com/v1/orders', JSON.stringify(payload), {
+    headers: { 'Content-Type': 'application/json' },
+  });
+
+  check(res, { 'status is 201': (r) => r.status === 201 });
+}
+`;
+  }
+  return `// ==========================================
+// k6 Load Test - Redis Key-Value Fetch
+// Requirements: xk6-redis
+// ==========================================
+import http from 'k6/http';
+import { check } from 'k6';
+import redis from 'k6/x/redis';
+
+const client = new redis.Client('redis://localhost:6379');
+
+export default function () {
+  const value = client.get('${keyName}');
+  const res = http.get(\`https://api.example.com/v1/item/\${value}\`);
+  check(res, { 'status is 200': (r) => r.status === 200 });
+}
+`;
+}
+
+// src/cli.ts
+async function main() {
+  const program = new import_commander.Command();
+  program.name("rediseed").description(
+    "Blazing-fast Redis data seeder & loader from CSV, JSON, and line streams for k6 load testing & staging fixtures."
+  ).version("1.0.0", "-v, --version", "Output current version");
+  program.option("-u, --url <url>", "Redis connection URL (e.g. redis://localhost:6379 or rediss:// for TLS)").option("-h, --host <host>", "Redis host", "127.0.0.1").option("-p, --port <port>", "Redis port", "6379").option("-a, --password <password>", "Redis auth password").option("-n, --db <db>", "Redis database index (0-15)", "0").option("--tls", "Enable TLS connection", false);
+  program.command("seed <file>").description("Load and seed data from CSV, JSON, or TXT file into Redis").option("-s, --structure <type>", "Redis structure: set, list, hash, string, zset", "set").option("-k, --key <name>", "Destination Redis key name or template (e.g. 'k6:user_ids' or 'user:{{id}}')", "seed:data").option("-c, --column <col>", "Extract specific column/property (for set, list, string)").option("--value <template>", "Value template for string/hash (e.g. '{{email}}:{{token}}')").option("--score-column <col>", "Column for zset score (defaults to timestamp)").option("-b, --batch-size <size>", "Pipeline batch size", "1000").option("--ttl <seconds>", "TTL expiration in seconds for keys").option("--flush", "Delete destination key before inserting", false).option("--dry-run", "Preview parsing and first 5 rows without writing to Redis", false).action(async (file, options) => {
+    try {
+      const globalOpts = program.opts();
+      console.log(import_picocolors.default.bold(`
+\u{1F331} rediseed \u2014 Loading data from: ${import_picocolors.default.cyan(file)}`));
+      const rows = loadAndParseFile(file);
+      console.log(`  \u2022 Parsed ${import_picocolors.default.green(rows.length.toLocaleString())} records.`);
+      if (options.dryRun) {
+        console.log(import_picocolors.default.yellow("\n[DRY RUN PREVIEW - First 5 items]"));
+        for (const row of rows.slice(0, 5)) {
+          console.log("  ", JSON.stringify(row));
+        }
+        console.log(import_picocolors.default.dim(`
+Would insert ${rows.length} items into Redis structure '${options.structure}' with key '${options.key}'.
+`));
+        return;
+      }
+      const redis = createRedisClient({
+        url: globalOpts.url,
+        host: globalOpts.host,
+        port: parseInt(globalOpts.port, 10),
+        password: globalOpts.password,
+        db: parseInt(globalOpts.db, 10),
+        tls: globalOpts.tls
+      });
+      const result = await executeSeed(redis, rows, {
+        structure: options.structure,
+        keyName: options.key,
+        column: options.column,
+        valueTemplate: options.value,
+        scoreColumn: options.scoreColumn,
+        batchSize: parseInt(options.batchSize, 10),
+        flushFirst: options.flush,
+        ttl: options.ttl ? parseInt(options.ttl, 10) : void 0
+      });
+      await redis.quit();
+      console.log(import_picocolors.default.green(`
+\u2714 Seeding completed successfully!`));
+      console.log(`  \u2022 Structure: ${import_picocolors.default.cyan(result.structure.toUpperCase())}`);
+      console.log(`  \u2022 Target Key: ${import_picocolors.default.cyan(options.key)}`);
+      console.log(`  \u2022 Total Items: ${import_picocolors.default.bold(result.totalInserted.toLocaleString())}`);
+      console.log(`  \u2022 Speed: ${import_picocolors.default.bold(result.opsPerSec.toLocaleString())} ops/sec (${result.elapsedMs}ms)
+`);
+    } catch (err) {
+      console.error(import_picocolors.default.red(`\u2716 Error: ${err.message || err}`));
+      process.exit(1);
+    }
+  });
+  program.command("set <keyName> <file>").description("Shortcut to load a file column directly into a Redis Set (ideal for k6 SPOP unique IDs)").option("-c, --column <col>", "Extract specific column name from CSV/JSON").option("--flush", "Delete set before inserting", false).action(async (keyName, file, options) => {
+    try {
+      const globalOpts = program.opts();
+      const rows = loadAndParseFile(file);
+      const redis = createRedisClient({
+        url: globalOpts.url,
+        host: globalOpts.host,
+        port: parseInt(globalOpts.port, 10),
+        password: globalOpts.password,
+        db: parseInt(globalOpts.db, 10),
+        tls: globalOpts.tls
+      });
+      const result = await executeSeed(redis, rows, {
+        structure: "set",
+        keyName,
+        column: options.column,
+        flushFirst: options.flush
+      });
+      await redis.quit();
+      console.log(import_picocolors.default.green(`
+\u2714 Successfully loaded ${result.totalInserted.toLocaleString()} unique items into Redis Set: ${import_picocolors.default.cyan(keyName)} (${result.elapsedMs}ms)`));
+    } catch (err) {
+      console.error(import_picocolors.default.red(`\u2716 Error: ${err.message || err}`));
+      process.exit(1);
+    }
+  });
+  program.command("inspect <key>").description("Inspect item count, data type, memory usage, and samples from a Redis key").option("-s, --samples <count>", "Number of sample items to preview", "5").action(async (key, options) => {
+    try {
+      const globalOpts = program.opts();
+      const redis = createRedisClient({
+        url: globalOpts.url,
+        host: globalOpts.host,
+        port: parseInt(globalOpts.port, 10),
+        password: globalOpts.password,
+        db: parseInt(globalOpts.db, 10),
+        tls: globalOpts.tls
+      });
+      const info = await inspectKey(redis, key, parseInt(options.samples, 10));
+      await redis.quit();
+      console.log(`
+${import_picocolors.default.bold("\u{1F50D} Redis Key Inspector")}`);
+      console.log(`  \u2022 Key: ${import_picocolors.default.cyan(info.key)}`);
+      console.log(`  \u2022 Type: ${import_picocolors.default.green(info.type.toUpperCase())}`);
+      console.log(`  \u2022 Total Items: ${import_picocolors.default.bold(info.count.toLocaleString())}`);
+      console.log(`  \u2022 TTL: ${info.ttl === -1 ? "No Expiration" : `${info.ttl}s`}`);
+      if (info.memoryBytes) {
+        console.log(`  \u2022 Memory Usage: ${(info.memoryBytes / 1024).toFixed(2)} KB`);
+      }
+      console.log(`
+${import_picocolors.default.bold("Sample Items:")}`);
+      for (const sample of info.samples) {
+        console.log(`  \u2022 ${sample}`);
+      }
+      console.log("");
+    } catch (err) {
+      console.error(import_picocolors.default.red(`\u2716 Error: ${err.message || err}`));
+      process.exit(1);
+    }
+  });
+  program.command("k6 <key>").description("Generate ready-to-use k6 load test script snippet consuming this Redis key").option("-s, --structure <type>", "Redis structure (set, list, string)", "set").action((key, options) => {
+    const snippet = generateK6Snippet(key, options.structure);
+    console.log(`
+${snippet}
+`);
+  });
+  await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map