@deniscuciuc/redis-analyzer 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0] - 2026-06-14
+
+### Added
+
+- Redis analyzer CLI with memory, hit-rate, persistence, replication, keyspace, connection, and slow-command commands
+- URI, host/port, TLS, password, and database-number connection support
+- `.analyzerrc.json` profiles, compare mode, HTML reports, and watch mode
+- Interactive CLI with report generation and runtime settings
+- Markdown, JSON, and HTML reports under `./reports/`
+- Diff reporting between JSON snapshots
+- Automated tests for option parsing, Redis INFO parsing, health scoring, and report generation
+- GitHub Actions CI and publish workflows
+- Dependabot configuration for npm and GitHub Actions
+- MIT license and OSS metadata
+
+### Changed
+
+- Full analysis generates Markdown, JSON, and optional HTML reports in one run
+
+### Fixed
+
+- Explicit `--profile` selection overrides sourced environment defaults for the active run

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Denis Cuciuc
+
+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,244 @@
+# Redis Analyzer
+
+[![Node.js 20+](https://img.shields.io/badge/node-20%2B-339933?logo=node.js)](https://nodejs.org/)
+[![npm version](https://img.shields.io/npm/v/@deniscuciuc/redis-analyzer?logo=npm&color=cb3837)](https://www.npmjs.com/package/@deniscuciuc/redis-analyzer)
+[![npm downloads](https://img.shields.io/npm/dm/@deniscuciuc/redis-analyzer)](https://www.npmjs.com/package/@deniscuciuc/redis-analyzer)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![TypeScript](https://img.shields.io/badge/types-TypeScript-3178C6?logo=typescript)](https://www.typescriptlang.org/)
+[![CI](https://github.com/deniscuciuc/db-analyzer-redis/actions/workflows/ci.yml/badge.svg)](https://github.com/deniscuciuc/db-analyzer-redis/actions/workflows/ci.yml)
+
+A CLI tool that analyzes Redis health with a focus on memory pressure, cache hit rate, persistence safety, replication lag, connection pressure, and slow commands. It emits structured JSON for automation or writes Markdown, JSON, and optional HTML reports to `./reports/`.
+
+## Quick start
+
+No installation required:
+
+```bash
+npx @deniscuciuc/redis-analyzer -h localhost -p 6379 -c health
+npx @deniscuciuc/redis-analyzer --uri redis://localhost:6379/0 -c full --json > report.json
+```
+
+Or install globally:
+
+```bash
+npm install -g @deniscuciuc/redis-analyzer
+redis-analyzer -h your-host -p 6379 -c health
+```
+
+> **Working with an AI agent?** See [.github/copilot-instructions.md](.github/copilot-instructions.md) for the integrated GitHub Copilot workflow and JSON contracts.
+
+---
+
+## Table of Contents
+
+- [Features](#features)
+- [Requirements](#requirements)
+- [Development / local setup](#development--local-setup)
+- [Configuration](#configuration)
+- [Usage](#usage)
+- [Commands](#commands)
+- [CLI options](#cli-options)
+- [Output formats](#output-formats)
+- [Health score](#health-score)
+- [Architecture](#architecture)
+- [Contributing](#contributing)
+
+---
+
+## Features
+
+- Memory usage analysis with fragmentation and RSS overhead checks
+- Cache hit-rate analysis with eviction and expiry context
+- Persistence safety checks for RDB and AOF
+- Replication health checks for standalone, primary, and replica nodes
+- Slow command analysis from `SLOWLOG`
+- Keyspace summaries by logical database
+- Interactive mode, compare mode, HTML reports, and watch mode for safe commands
+
+## Requirements
+
+- Node.js >= 20
+- pnpm >= 10
+- Redis 6+
+
+## Development / local setup
+
+```bash
+pnpm install
+cp .env.example .env
+# edit .env with your Redis connection details
+pnpm build
+node dist/index.js --help
+```
+
+## Configuration
+
+### Environment variables (`.env`)
+
+```bash
+export REDIS_HOST=localhost
+export REDIS_PORT=6379
+export REDIS_DB=0
+export REDIS_PASSWORD=secret
+export REDIS_TLS=false
+
+# Alternative: URI format
+# export REDIS_URI=redis://:secret@redis.internal:6379/0
+```
+
+### Config file (`.analyzerrc.json`)
+
+Place `.analyzerrc.json` in your project root (or `~/.config/db-analyzer/config.json` for global settings). Copy `analyzerrc.example.json` to get started:
+
+```bash
+cp analyzerrc.example.json .analyzerrc.json
+```
+
+Profiles let you switch between Redis instances:
+
+```bash
+. ./.env && npx ts-node index.ts -c health --profile prod
+pnpm analyze:health -- --profile local
+```
+
+CLI flags always win. When you explicitly select `--profile`, that profile overrides the sourced environment defaults for that run.
+
+## Usage
+
+### Interactive mode
+
+```bash
+pnpm start
+```
+
+### npm scripts
+
+```bash
+pnpm analyze
+pnpm analyze:help
+pnpm analyze:health
+pnpm analyze:memory
+pnpm analyze:hit-rate
+pnpm analyze:slow
+pnpm analyze:keys
+pnpm analyze:connections
+pnpm analyze:persistence
+pnpm analyze:replication
+pnpm analyze:config
+pnpm analyze:html
+pnpm analyze:watch
+pnpm server:info
+pnpm build
+pnpm lint
+pnpm test
+```
+
+### Direct CLI
+
+```bash
+. ./.env && npx ts-node index.ts -j -c health
+. ./.env && npx ts-node index.ts -j -c slow-commands --slow-threshold 5000
+npx ts-node index.ts --uri redis://localhost:6379/0 -c full --html
+```
+
+---
+
+## Commands
+
+| Command | Description |
+| ------- | ----------- |
+| `full` | Complete analysis (default) |
+| `health` | Health score and key metrics |
+| `server-info` | Redis version, mode, uptime, config file |
+| `memory` | Memory usage, fragmentation, and overhead |
+| `hit-rate` | Cache hit ratio, expirations, and evictions |
+| `slow-commands` | `SLOWLOG` analysis with top command types |
+| `keys` | Keyspace counts, expiries, and average TTL |
+| `connections` | Connected, blocked, rejected, and buffer metrics |
+| `persistence` | RDB and AOF health |
+| `replication` | Primary / replica status and lag |
+| `config` | Important Redis configuration values |
+
+## CLI options
+
+| Option | Short | Description | Default |
+| ------ | ----- | ----------- | ------- |
+| `--host` | `-h` | Redis host | `localhost` |
+| `--port` | `-p` | Redis port | `6379` |
+| `--password` | `-a` | Redis password | - |
+| `--db` | `-n` | Database number | `0` |
+| `--tls` |  | Enable TLS | `false` |
+| `--uri` |  | Redis URI (`redis://...`) | - |
+| `--profile` |  | Use named profile from `.analyzerrc.json` | - |
+| `--config` |  | Use a custom config file path | auto-search |
+| `--slow-threshold` |  | Slow command threshold in microseconds | `10000` |
+| `--max-slow-commands` |  | Max `SLOWLOG` rows to fetch | `25` |
+| `--compare` |  | Compare against a previous JSON report | - |
+| `--watch` |  | Poll interval in seconds | - |
+| `--command` | `-c` | Run a specific analysis command | `full` |
+| `--json` | `-j` | Output JSON | `false` |
+| `--quiet` | `-q` | Suppress non-essential output | `false` |
+| `--output` | `-o` | Reports directory | `./reports` |
+| `--html` |  | Also generate an HTML report | `false` |
+| `--interactive` | `-i` | Interactive menu | `false` |
+
+---
+
+## Output formats
+
+### JSON
+
+Use `-j` to emit machine-readable JSON to stdout.
+
+### Markdown / HTML reports
+
+`full` analysis writes:
+
+- Markdown report
+- JSON report
+- Optional HTML report when `--html` is set
+
+### Compare mode
+
+Compare two snapshots:
+
+```bash
+. ./.env && npx ts-node index.ts -c full --compare ./reports/redis-analysis-prev.json
+```
+
+## Health score
+
+The analyzer starts at **100** and deducts points for:
+
+- high memory usage or fragmentation
+- low cache hit rate
+- failed or stale persistence
+- replication lag or broken links
+- rejected client connections
+
+Score guide:
+
+| Score | Status |
+| ----- | ------ |
+| 90-100 | Excellent |
+| 70-89 | Good |
+| 50-69 | Warning |
+| 0-49 | Critical |
+
+## Architecture
+
+```text
+index.ts                              # CLI bootstrap and Redis connection setup
+src/cli/{options,runner}.ts           # CLI parsing and command execution
+src/config/loader.ts                  # Config loading and profile resolution
+src/collectors/stats-collector.ts     # INFO / SLOWLOG / CONFIG collection
+src/analyzers/*.ts                    # Memory, performance, persistence, replication analysis
+src/reporters/*.ts                    # Markdown, HTML, and diff rendering
+src/interactive/{index,display,menus}.ts
+src/watch/runner.ts                   # Watch mode loop
+tests/*.test.ts                       # Automated tests
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).

package/analyzerrc.example.json

@@ -0,0 +1,17 @@
+{
+  "profiles": {
+    "local": {
+      "host": "localhost",
+      "port": 6379,
+      "db": 0
+    },
+    "prod": {
+      "uri": "redis://:password@prod-redis.internal:6379/0",
+      "tls": true
+    }
+  },
+  "defaultProfile": "local",
+  "slowCommandThreshold": 10000,
+  "maxSlowCommands": 25,
+  "output": "./reports"
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ioredis_1 = __importDefault(require("ioredis"));
+const options_1 = require("./src/cli/options");
+const runner_1 = require("./src/cli/runner");
+const loader_1 = require("./src/config/loader");
+const constants_1 = require("./src/constants");
+const interactive_1 = require("./src/interactive");
+const runner_2 = require("./src/watch/runner");
+function resolveValue(cliValue, envValue, profileValue, fallbackValue, preferProfile) {
+    if (cliValue !== undefined && cliValue !== fallbackValue) {
+        return cliValue;
+    }
+    if (preferProfile) {
+        return profileValue ?? envValue ?? cliValue ?? fallbackValue;
+    }
+    return envValue ?? profileValue ?? cliValue ?? fallbackValue;
+}
+function resolveOptionalValue(cliValue, envValue, profileValue, preferProfile) {
+    if (cliValue !== undefined) {
+        return cliValue;
+    }
+    if (preferProfile) {
+        return profileValue ?? envValue;
+    }
+    return envValue ?? profileValue;
+}
+function parseNumber(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseBoolean(value) {
+    if (!value) {
+        return undefined;
+    }
+    return value === "true" || value === "1";
+}
+function resolveConnectionDetails(connection) {
+    if (!connection.uri) {
+        return connection;
+    }
+    try {
+        const parsed = new URL(connection.uri);
+        return {
+            ...connection,
+            host: parsed.hostname || connection.host,
+            port: parsed.port ? Number.parseInt(parsed.port, 10) : connection.port,
+            db: parsed.pathname
+                ? Number.parseInt(parsed.pathname.replace("/", ""), 10) || connection.db
+                : connection.db,
+        };
+    }
+    catch {
+        return connection;
+    }
+}
+async function closeClient(client) {
+    try {
+        await client.quit();
+    }
+    catch {
+        client.disconnect();
+    }
+}
+async function main() {
+    const options = (0, options_1.parseOptions)();
+    const config = (0, loader_1.loadConfig)(options.config);
+    const profile = (0, loader_1.resolveProfile)(config, options.profile);
+    const preferProfile = Boolean(options.profile);
+    if (options.watch !== undefined && options.json) {
+        throw new Error("--watch cannot be combined with --json.");
+    }
+    const connection = resolveConnectionDetails({
+        host: resolveValue(options.host, process.env.REDIS_HOST, profile.host, constants_1.DEFAULTS.host, preferProfile),
+        port: resolveValue(options.port, parseNumber(process.env.REDIS_PORT), profile.port, constants_1.DEFAULTS.port, preferProfile),
+        password: resolveOptionalValue(options.password, process.env.REDIS_PASSWORD, profile.password, preferProfile),
+        db: resolveValue(options.db, parseNumber(process.env.REDIS_DB), profile.db, constants_1.DEFAULTS.db, preferProfile),
+        tls: resolveValue(options.tls, parseBoolean(process.env.REDIS_TLS), profile.tls, false, preferProfile),
+        uri: resolveOptionalValue(options.uri, process.env.REDIS_URI, profile.uri, preferProfile),
+    });
+    const runtimeOptions = {
+        ...options,
+        outputDir: resolveValue(options.outputDir, undefined, config.output, constants_1.DEFAULTS.output, false),
+        slowCommandThreshold: resolveValue(options.slowCommandThreshold, undefined, config.slowCommandThreshold, constants_1.DEFAULTS.slowCommandThreshold, false),
+        maxSlowCommands: resolveValue(options.maxSlowCommands, undefined, config.maxSlowCommands, constants_1.DEFAULTS.maxSlowCommands, false),
+    };
+    const client = connection.uri
+        ? new ioredis_1.default(connection.uri, {
+            lazyConnect: true,
+            tls: connection.tls ? {} : undefined,
+        })
+        : new ioredis_1.default({
+            host: connection.host,
+            port: connection.port,
+            password: connection.password,
+            db: connection.db,
+            tls: connection.tls ? {} : undefined,
+            lazyConnect: true,
+        });
+    try {
+        await client.connect();
+        await client.ping();
+        if (runtimeOptions.interactive) {
+            const interactive = new interactive_1.InteractiveCLI(client, connection, runtimeOptions);
+            await interactive.start();
+            return;
+        }
+        if (runtimeOptions.watch !== undefined) {
+            await (0, runner_2.runWatchLoop)({
+                intervalSeconds: runtimeOptions.watch,
+                command: runtimeOptions.command,
+                runCommand: () => (0, runner_1.executeCommand)(client, runtimeOptions, connection),
+            });
+            return;
+        }
+        await (0, runner_1.executeCommand)(client, runtimeOptions, connection);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Cannot connect to Redis: ${message}`);
+    }
+    finally {
+        await closeClient(client);
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("Error during analysis:", message);
+    process.exit(1);
+});

package/dist/src/analyzers/memory-analyzer.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryAnalysis, RedisInfo } from "../types";
+export declare class MemoryAnalyzer {
+    analyze(info: RedisInfo): MemoryAnalysis;
+}
+//# sourceMappingURL=memory-analyzer.d.ts.map

package/dist/src/analyzers/memory-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-analyzer.d.ts","sourceRoot":"","sources":["../../../src/analyzers/memory-analyzer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAG1D,qBAAa,cAAc;IAC1B,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc;CA+DxC"}

package/dist/src/analyzers/memory-analyzer.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAnalyzer = void 0;
+const constants_1 = require("../constants");
+const format_1 = require("../utils/format");
+class MemoryAnalyzer {
+    analyze(info) {
+        const hasLimit = info.maxmemory > 0;
+        const usagePercent = hasLimit
+            ? (info.usedMemory / info.maxmemory) * 100
+            : 0;
+        const fragRatio = info.memFragmentationRatio;
+        const fragSeverity = fragRatio >= constants_1.THRESHOLDS.memory.fragCritical
+            ? "critical"
+            : fragRatio >= constants_1.THRESHOLDS.memory.fragWarning
+                ? "warning"
+                : "ok";
+        const recommendations = [];
+        if (hasLimit && usagePercent >= constants_1.THRESHOLDS.memory.usageCritical) {
+            recommendations.push(`Memory usage at ${usagePercent.toFixed(1)}% — increase maxmemory or reduce data size immediately.`);
+        }
+        else if (hasLimit && usagePercent >= constants_1.THRESHOLDS.memory.usageWarning) {
+            recommendations.push(`Memory at ${usagePercent.toFixed(1)}% of maxmemory — plan capacity increase.`);
+        }
+        if (!hasLimit) {
+            recommendations.push("maxmemory is not set — Redis will grow until an OOM kill unless the host limits it.");
+        }
+        if (fragSeverity === "critical") {
+            recommendations.push(`High fragmentation ratio ${fragRatio.toFixed(2)} (${(0, format_1.formatBytes)(info.memFragmentationBytes)} wasted). Run MEMORY PURGE or restart Redis during a low-traffic window.`);
+        }
+        else if (fragSeverity === "warning") {
+            recommendations.push(`Moderate fragmentation ratio ${fragRatio.toFixed(2)}. Monitor allocator pressure and peak RSS.`);
+        }
+        if (info.usedMemory > 0 && info.usedMemoryRss > info.usedMemory * 2) {
+            recommendations.push(`RSS (${(0, format_1.formatBytes)(info.usedMemoryRss)}) is more than 2x allocated memory (${info.usedMemoryHuman}). Consider MEMORY PURGE, jemalloc tuning, or a controlled restart.`);
+        }
+        return {
+            usedMemory: info.usedMemory,
+            usedMemoryHuman: info.usedMemoryHuman,
+            maxMemory: info.maxmemory,
+            maxMemoryHuman: info.maxmemoryHuman,
+            usagePercent,
+            fragRatio,
+            fragBytes: info.memFragmentationBytes,
+            fragSeverity,
+            rssOverhead: info.usedMemoryRss - info.usedMemory,
+            peakMemory: info.usedMemoryPeak,
+            dataMemory: info.usedMemoryDataset,
+            overheadMemory: info.usedMemoryOverhead,
+            recommendations,
+        };
+    }
+}
+exports.MemoryAnalyzer = MemoryAnalyzer;

package/dist/src/analyzers/performance-analyzer.d.ts

@@ -0,0 +1,6 @@
+import type { HitRateAnalysis, RedisInfo, SlowCommand, SlowCommandAnalysis } from "../types";
+export declare class PerformanceAnalyzer {
+    analyzeHitRate(info: RedisInfo): HitRateAnalysis;
+    analyzeSlowCommands(commands: SlowCommand[], totalLogged: number, threshold: number): SlowCommandAnalysis;
+}
+//# sourceMappingURL=performance-analyzer.d.ts.map

package/dist/src/analyzers/performance-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance-analyzer.d.ts","sourceRoot":"","sources":["../../../src/analyzers/performance-analyzer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,eAAe,EACf,SAAS,EACT,WAAW,EACX,mBAAmB,EAEnB,MAAM,UAAU,CAAC;AAElB,qBAAa,mBAAmB;IAC/B,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe;IAwChD,mBAAmB,CAClB,QAAQ,EAAE,WAAW,EAAE,EACvB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GACf,mBAAmB;CAmDtB"}

package/dist/src/analyzers/performance-analyzer.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceAnalyzer = void 0;
+const constants_1 = require("../constants");
+class PerformanceAnalyzer {
+    analyzeHitRate(info) {
+        const total = info.keyspaceHits + info.keyspaceMisses;
+        const hitRate = total === 0 ? 100 : (info.keyspaceHits / total) * 100;
+        const evictionSeverity = info.evictedKeys > 0 && info.maxmemoryPolicy === "noeviction"
+            ? "critical"
+            : info.evictedKeys > 1000
+                ? "warning"
+                : "ok";
+        const recommendations = [];
+        if (hitRate < constants_1.THRESHOLDS.hitRate.critical) {
+            recommendations.push(`Cache hit rate is critically low at ${hitRate.toFixed(1)}%. Review TTL strategy, memory sizing, and whether Redis is serving the right workload.`);
+        }
+        else if (hitRate < constants_1.THRESHOLDS.hitRate.warning) {
+            recommendations.push(`Cache hit rate ${hitRate.toFixed(1)}% is below the 90% target. Review hot keys, eviction pressure, and expiry policy.`);
+        }
+        if (info.evictedKeys > 0) {
+            recommendations.push(`${info.evictedKeys.toLocaleString()} keys have been evicted (policy: ${info.maxmemoryPolicy}). Increase headroom or adjust TTL and eviction policy.`);
+        }
+        return {
+            hits: info.keyspaceHits,
+            misses: info.keyspaceMisses,
+            hitRate,
+            evictedKeys: info.evictedKeys,
+            expiredKeys: info.expiredKeys,
+            evictionPolicy: info.maxmemoryPolicy,
+            evictionSeverity,
+            recommendations,
+        };
+    }
+    analyzeSlowCommands(commands, totalLogged, threshold) {
+        const byCommand = new Map();
+        for (const command of commands) {
+            const name = command.command[0]?.toUpperCase() ?? "UNKNOWN";
+            const current = byCommand.get(name) ?? { count: 0, totalMs: 0 };
+            byCommand.set(name, {
+                count: current.count + 1,
+                totalMs: current.totalMs + command.durationMs,
+            });
+        }
+        const topCommandTypes = [...byCommand.entries()]
+            .sort((left, right) => right[1].count - left[1].count)
+            .slice(0, 5)
+            .map(([command, summary]) => ({
+            command,
+            count: summary.count,
+            avgMs: summary.totalMs / summary.count,
+        }));
+        const recommendations = [];
+        if (totalLogged > 100) {
+            recommendations.push(`${totalLogged} slow commands were logged. Check for O(N) operations such as KEYS, large set scans, or long list traversals.`);
+        }
+        const dangerousCommands = new Set([
+            "KEYS",
+            "FLUSHDB",
+            "FLUSHALL",
+            "DEBUG",
+            "CONFIG",
+        ]);
+        for (const command of topCommandTypes) {
+            if (dangerousCommands.has(command.command)) {
+                recommendations.push(`${command.command} appears in the slow log. Replace KEYS with SCAN and avoid administrative commands on the hot path.`);
+            }
+        }
+        return {
+            totalLogged,
+            commands,
+            topCommandTypes,
+            threshold,
+            recommendations,
+        };
+    }
+}
+exports.PerformanceAnalyzer = PerformanceAnalyzer;

package/dist/src/analyzers/persistence-analyzer.d.ts

@@ -0,0 +1,5 @@
+import type { PersistenceAnalysis, RedisInfo } from "../types";
+export declare class PersistenceAnalyzer {
+    analyze(info: RedisInfo): PersistenceAnalysis;
+}
+//# sourceMappingURL=persistence-analyzer.d.ts.map

package/dist/src/analyzers/persistence-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence-analyzer.d.ts","sourceRoot":"","sources":["../../../src/analyzers/persistence-analyzer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE/D,qBAAa,mBAAmB;IAC/B,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,mBAAmB;CAsE7C"}