@deniscuciuc/redis-analyzer 1.0.0

package/dist/src/collectors/stats-collector.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsCollector = void 0;
+exports.parseSlowLogEntries = parseSlowLogEntries;
+exports.parseRedisInfo = parseRedisInfo;
+function parseSlowLogEntries(entries) {
+    return entries.map((entry) => {
+        const args = Array.isArray(entry[3]) ? entry[3] : [];
+        return {
+            id: Number(entry[0]),
+            timestamp: Number(entry[1]),
+            durationMicros: Number(entry[2]),
+            durationMs: Number(entry[2]) / 1000,
+            command: args,
+            commandPreview: args.slice(0, 3).join(" ").substring(0, 80),
+            clientAddr: entry[4]?.toString(),
+        };
+    });
+}
+function parseRedisInfo(raw) {
+    const lines = raw.split("\r\n");
+    const map = {};
+    for (const line of lines) {
+        if (line.startsWith("#") || !line.includes(":")) {
+            continue;
+        }
+        const [key, ...rest] = line.split(":");
+        map[key.trim()] = rest.join(":").trim();
+    }
+    const keyspaces = [];
+    for (const [key, value] of Object.entries(map)) {
+        if (!key.startsWith("db")) {
+            continue;
+        }
+        const db = Number(key.slice(2));
+        if (Number.isNaN(db)) {
+            continue;
+        }
+        const parts = {};
+        for (const part of value.split(",")) {
+            const [partKey, partValue] = part.split("=");
+            parts[partKey] = Number(partValue);
+        }
+        keyspaces.push({
+            db,
+            keys: parts.keys ?? 0,
+            expires: parts.expires ?? 0,
+            avgTtl: parts.avg_ttl ?? 0,
+        });
+    }
+    const get = (key, fallback = "0") => map[key] ?? fallback;
+    const number = (key) => Number(get(key));
+    return {
+        redisVersion: get("redis_version", "unknown"),
+        redisMode: get("redis_mode", "standalone"),
+        os: get("os", "unknown"),
+        uptimeInSeconds: number("uptime_in_seconds"),
+        uptimeInDays: number("uptime_in_days"),
+        tcpPort: number("tcp_port"),
+        executablePath: get("executable"),
+        configFile: get("config_file"),
+        connectedClients: number("connected_clients"),
+        blockedClients: number("blocked_clients"),
+        maxClients: number("maxclients"),
+        clientRecentMaxInputBuffer: number("client_recent_max_input_buffer"),
+        clientRecentMaxOutputBuffer: number("client_recent_max_output_buffer"),
+        usedMemory: number("used_memory"),
+        usedMemoryHuman: get("used_memory_human"),
+        usedMemoryRss: number("used_memory_rss"),
+        usedMemoryRssHuman: get("used_memory_rss_human"),
+        usedMemoryPeak: number("used_memory_peak"),
+        usedMemoryPeakHuman: get("used_memory_peak_human"),
+        usedMemoryPeakPerc: Number(get("used_memory_peak_perc", "0").replace("%", "")),
+        usedMemoryOverhead: number("used_memory_overhead"),
+        usedMemoryDataset: number("used_memory_dataset"),
+        memFragmentationRatio: Number(get("mem_fragmentation_ratio", "0")),
+        memFragmentationBytes: number("mem_fragmentation_bytes"),
+        maxmemory: number("maxmemory"),
+        maxmemoryHuman: get("maxmemory_human"),
+        maxmemoryPolicy: get("maxmemory_policy", "noeviction"),
+        totalCommandsProcessed: number("total_commands_processed"),
+        instantaneousOpsPerSec: number("instantaneous_ops_per_sec"),
+        totalNetInputBytes: number("total_net_input_bytes"),
+        totalNetOutputBytes: number("total_net_output_bytes"),
+        rejectedConnections: number("rejected_connections"),
+        expiredKeys: number("expired_keys"),
+        evictedKeys: number("evicted_keys"),
+        keyspaceHits: number("keyspace_hits"),
+        keyspaceMisses: number("keyspace_misses"),
+        role: get("role", "master"),
+        connectedSlaves: number("connected_slaves"),
+        masterLinkStatus: map.master_link_status,
+        masterLastIoSecondsAgo: map.master_last_io_seconds_ago
+            ? number("master_last_io_seconds_ago")
+            : undefined,
+        masterSyncInProgress: map.master_sync_in_progress
+            ? get("master_sync_in_progress") === "1"
+            : undefined,
+        masterReplOffset: map.master_repl_offset
+            ? number("master_repl_offset")
+            : undefined,
+        slaveReplOffset: map.slave_repl_offset
+            ? number("slave_repl_offset")
+            : undefined,
+        rdbChangesSinceLastSave: number("rdb_changes_since_last_save"),
+        rdbBgsaveInProgress: get("rdb_bgsave_in_progress") === "1",
+        rdbLastSaveTime: number("rdb_last_save_time"),
+        rdbLastBgsaveStatus: get("rdb_last_bgsave_status", "ok"),
+        rdbLastBgsaveTimeSec: number("rdb_last_bgsave_time_sec"),
+        aofEnabled: get("aof_enabled") === "1",
+        aofRewriteInProgress: get("aof_rewrite_in_progress") === "1",
+        aofLastRewriteTimeSec: number("aof_last_rewrite_time_sec"),
+        aofLastBgrewriteStatus: get("aof_last_bgrewrite_status", "ok"),
+        aofCurrentSize: map.aof_current_size
+            ? number("aof_current_size")
+            : undefined,
+        keyspaces,
+    };
+}
+class StatsCollector {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getInfo() {
+        return parseRedisInfo(await this.client.info("all"));
+    }
+    async getSlowLog(count) {
+        const raw = (await this.client.slowlog("GET", count));
+        return parseSlowLogEntries(raw);
+    }
+    async getSlowLogLength() {
+        const raw = await this.client.slowlog("LEN");
+        return Number(raw);
+    }
+    async getConfigValues(keys) {
+        const config = {};
+        for (const key of keys) {
+            const raw = (await this.client.config("GET", key));
+            for (let index = 0; index < raw.length; index += 2) {
+                const configKey = raw[index];
+                const value = raw[index + 1];
+                if (configKey && value !== undefined) {
+                    config[configKey] = value;
+                }
+            }
+        }
+        return config;
+    }
+}
+exports.StatsCollector = StatsCollector;

package/dist/src/config/loader.d.ts

@@ -0,0 +1,13 @@
+import type { RedisConnection } from "../types";
+export type ProfileConfig = Partial<RedisConnection>;
+export interface AnalyzerConfig {
+    profiles?: Record<string, ProfileConfig>;
+    defaultProfile?: string;
+    slowCommandThreshold?: number;
+    maxSlowCommands?: number;
+    output?: string;
+}
+export declare function loadConfig(configPath?: string): AnalyzerConfig;
+export declare function resolveProfile(config: AnalyzerConfig, profileName?: string): ProfileConfig;
+export declare function listProfiles(config: AnalyzerConfig): string[];
+//# sourceMappingURL=loader.d.ts.map

package/dist/src/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/config/loader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AAErD,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACzC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAMD,wBAAgB,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,cAAc,CAsC9D;AAED,wBAAgB,cAAc,CAC7B,MAAM,EAAE,cAAc,EACtB,WAAW,CAAC,EAAE,MAAM,GAClB,aAAa,CAsBf;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,EAAE,CAE7D"}

package/dist/src/config/loader.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.resolveProfile = resolveProfile;
+exports.listProfiles = listProfiles;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+function parseConfig(candidate) {
+    return JSON.parse((0, node_fs_1.readFileSync)(candidate, "utf-8"));
+}
+function loadConfig(configPath) {
+    if (configPath) {
+        const explicitPath = (0, node_path_1.resolve)(configPath);
+        if (!(0, node_fs_1.existsSync)(explicitPath)) {
+            throw new Error(`Config file not found: ${explicitPath}`);
+        }
+        try {
+            return parseConfig(explicitPath);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Could not parse config file at ${explicitPath}: ${message}`);
+        }
+    }
+    const candidates = [
+        (0, node_path_1.join)(process.cwd(), ".analyzerrc.json"),
+        (0, node_path_1.join)((0, node_os_1.homedir)(), ".config", "db-analyzer", "config.json"),
+    ];
+    for (const candidate of candidates) {
+        if (!(0, node_fs_1.existsSync)(candidate)) {
+            continue;
+        }
+        try {
+            return parseConfig(candidate);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Warning: could not parse config file at ${candidate}: ${message}`);
+        }
+    }
+    return {};
+}
+function resolveProfile(config, profileName) {
+    if (!config.profiles) {
+        if (profileName) {
+            throw new Error(`Profile "${profileName}" was requested, but no profiles were found in the config file.`);
+        }
+        return {};
+    }
+    const name = profileName ?? config.defaultProfile;
+    if (!name) {
+        return {};
+    }
+    const profile = config.profiles[name];
+    if (!profile) {
+        throw new Error(`Profile "${name}" not found in config file.`);
+    }
+    return profile;
+}
+function listProfiles(config) {
+    return Object.keys(config.profiles ?? {});
+}

package/dist/src/constants.d.ts

@@ -0,0 +1,52 @@
+export declare const COMMANDS: readonly ["full", "health", "server-info", "memory", "hit-rate", "slow-commands", "keys", "connections", "persistence", "replication", "config"];
+export type Command = (typeof COMMANDS)[number];
+export declare const WATCH_ALLOWED: Set<"full" | "health" | "server-info" | "memory" | "hit-rate" | "slow-commands" | "keys" | "connections" | "persistence" | "replication" | "config">;
+export declare const WATCH_BLOCKED: Set<"full" | "health" | "server-info" | "memory" | "hit-rate" | "slow-commands" | "keys" | "connections" | "persistence" | "replication" | "config">;
+export declare const FULL_ANALYSIS_COMMANDS: Command[];
+export declare const THRESHOLDS: {
+    readonly memory: {
+        readonly usageWarning: 70;
+        readonly usageCritical: 90;
+        readonly fragWarning: 1.5;
+        readonly fragCritical: 2;
+    };
+    readonly hitRate: {
+        readonly warning: 90;
+        readonly critical: 80;
+    };
+    readonly replication: {
+        readonly lagWarning: 10;
+        readonly lagCritical: 60;
+    };
+    readonly persistence: {
+        readonly rdbStaleHours: 24;
+    };
+    readonly slowCommand: {
+        readonly defaultThresholdMicros: 10000;
+    };
+};
+export declare const SCORE_DEDUCTIONS: {
+    readonly memoryUsageCritical: 20;
+    readonly memoryUsageWarning: 10;
+    readonly highFragmentation: 15;
+    readonly lowHitRate: 20;
+    readonly veryLowHitRate: 10;
+    readonly linkDown: 25;
+    readonly highReplicationLag: 15;
+    readonly rdbFailed: 20;
+    readonly aofFailed: 20;
+    readonly stalePersistence: 10;
+    readonly highEviction: 10;
+    readonly rejectedConnections: 15;
+};
+export declare const DEFAULTS: {
+    readonly host: "localhost";
+    readonly port: 6379;
+    readonly db: 0;
+    readonly slowCommandThreshold: 10000;
+    readonly maxSlowCommands: 25;
+    readonly output: "./reports";
+    readonly watchInterval: 30;
+};
+export declare const IMPORTANT_CONFIG_KEYS: readonly ["maxmemory", "maxmemory-policy", "appendonly", "appendfsync", "save", "timeout", "tcp-keepalive", "slowlog-log-slower-than", "slowlog-max-len", "databases"];
+//# sourceMappingURL=constants.d.ts.map

package/dist/src/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,kJAYX,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhD,eAAO,MAAM,aAAa,sJAOxB,CAAC;AAEH,eAAO,MAAM,aAAa,sJAAuB,CAAC;AAElD,eAAO,MAAM,sBAAsB,EAAE,OAAO,EAU3C,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;CAqBb,CAAC;AAEX,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAanB,CAAC;AAEX,eAAO,MAAM,QAAQ;;;;;;;;CAQX,CAAC;AAEX,eAAO,MAAM,qBAAqB,wKAWxB,CAAC"}

package/dist/src/constants.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMPORTANT_CONFIG_KEYS = exports.DEFAULTS = exports.SCORE_DEDUCTIONS = exports.THRESHOLDS = exports.FULL_ANALYSIS_COMMANDS = exports.WATCH_BLOCKED = exports.WATCH_ALLOWED = exports.COMMANDS = void 0;
+exports.COMMANDS = [
+    "full",
+    "health",
+    "server-info",
+    "memory",
+    "hit-rate",
+    "slow-commands",
+    "keys",
+    "connections",
+    "persistence",
+    "replication",
+    "config",
+];
+exports.WATCH_ALLOWED = new Set([
+    "health",
+    "connections",
+    "hit-rate",
+    "slow-commands",
+    "keys",
+    "replication",
+]);
+exports.WATCH_BLOCKED = new Set([]);
+exports.FULL_ANALYSIS_COMMANDS = [
+    "health",
+    "memory",
+    "hit-rate",
+    "slow-commands",
+    "keys",
+    "connections",
+    "persistence",
+    "replication",
+    "config",
+];
+exports.THRESHOLDS = {
+    memory: {
+        usageWarning: 70,
+        usageCritical: 90,
+        fragWarning: 1.5,
+        fragCritical: 2.0,
+    },
+    hitRate: {
+        warning: 90,
+        critical: 80,
+    },
+    replication: {
+        lagWarning: 10,
+        lagCritical: 60,
+    },
+    persistence: {
+        rdbStaleHours: 24,
+    },
+    slowCommand: {
+        defaultThresholdMicros: 10_000,
+    },
+};
+exports.SCORE_DEDUCTIONS = {
+    memoryUsageCritical: 20,
+    memoryUsageWarning: 10,
+    highFragmentation: 15,
+    lowHitRate: 20,
+    veryLowHitRate: 10,
+    linkDown: 25,
+    highReplicationLag: 15,
+    rdbFailed: 20,
+    aofFailed: 20,
+    stalePersistence: 10,
+    highEviction: 10,
+    rejectedConnections: 15,
+};
+exports.DEFAULTS = {
+    host: "localhost",
+    port: 6379,
+    db: 0,
+    slowCommandThreshold: 10_000,
+    maxSlowCommands: 25,
+    output: "./reports",
+    watchInterval: 30,
+};
+exports.IMPORTANT_CONFIG_KEYS = [
+    "maxmemory",
+    "maxmemory-policy",
+    "appendonly",
+    "appendfsync",
+    "save",
+    "timeout",
+    "tcp-keepalive",
+    "slowlog-log-slower-than",
+    "slowlog-max-len",
+    "databases",
+];

package/dist/src/health.d.ts

@@ -0,0 +1,10 @@
+import type { FullRedisReport, HitRateAnalysis, MemoryAnalysis, PersistenceAnalysis, Recommendation, RedisMetrics, ReplicationAnalysis } from "./types";
+export declare function computeHealthScore(report: Omit<FullRedisReport, "healthScore" | "recommendations">): number;
+export declare function buildRecommendations(input: {
+    memory: MemoryAnalysis;
+    hitRate: HitRateAnalysis;
+    persistence: PersistenceAnalysis;
+    replication: ReplicationAnalysis;
+    metrics: RedisMetrics;
+}): Recommendation[];
+//# sourceMappingURL=health.d.ts.map

package/dist/src/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../src/health.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,eAAe,EACf,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,MAAM,SAAS,CAAC;AASjB,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,aAAa,GAAG,iBAAiB,CAAC,GAC9D,MAAM,CA+CR;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC3C,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,WAAW,EAAE,mBAAmB,CAAC;IACjC,WAAW,EAAE,mBAAmB,CAAC;IACjC,OAAO,EAAE,YAAY,CAAC;CACtB,GAAG,cAAc,EAAE,CAiEnB"}

package/dist/src/health.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeHealthScore = computeHealthScore;
+exports.buildRecommendations = buildRecommendations;
+const constants_1 = require("./constants");
+const PRIORITY_ORDER = {
+    critical: 0,
+    high: 1,
+    medium: 2,
+    low: 3,
+};
+function computeHealthScore(report) {
+    let score = 100;
+    const { memory, hitRate, persistence, replication } = report;
+    if (memory.maxMemory > 0) {
+        if (memory.usagePercent >= constants_1.THRESHOLDS.memory.usageCritical) {
+            score -= constants_1.SCORE_DEDUCTIONS.memoryUsageCritical;
+        }
+        else if (memory.usagePercent >= constants_1.THRESHOLDS.memory.usageWarning) {
+            score -= constants_1.SCORE_DEDUCTIONS.memoryUsageWarning;
+        }
+    }
+    if (memory.fragSeverity === "critical") {
+        score -= constants_1.SCORE_DEDUCTIONS.highFragmentation;
+    }
+    if (hitRate.hitRate < constants_1.THRESHOLDS.hitRate.critical) {
+        score -= constants_1.SCORE_DEDUCTIONS.lowHitRate + constants_1.SCORE_DEDUCTIONS.veryLowHitRate;
+    }
+    else if (hitRate.hitRate < constants_1.THRESHOLDS.hitRate.warning) {
+        score -= constants_1.SCORE_DEDUCTIONS.lowHitRate;
+    }
+    if (hitRate.evictedKeys > 1000) {
+        score -= constants_1.SCORE_DEDUCTIONS.highEviction;
+    }
+    if (persistence.rdb.lastStatus === "err") {
+        score -= constants_1.SCORE_DEDUCTIONS.rdbFailed;
+    }
+    if (persistence.aof.enabled && persistence.aof.lastStatus === "err") {
+        score -= constants_1.SCORE_DEDUCTIONS.aofFailed;
+    }
+    if (persistence.severity === "warning") {
+        score -= constants_1.SCORE_DEDUCTIONS.stalePersistence;
+    }
+    if (replication.linkStatus === "down") {
+        score -= constants_1.SCORE_DEDUCTIONS.linkDown;
+    }
+    else if (replication.severity === "warning") {
+        score -= constants_1.SCORE_DEDUCTIONS.highReplicationLag;
+    }
+    if (report.metrics.rejectedConnections > 0) {
+        score -= constants_1.SCORE_DEDUCTIONS.rejectedConnections;
+    }
+    return Math.max(0, score);
+}
+function buildRecommendations(input) {
+    const recommendations = [];
+    recommendations.push(...toRecommendations("memory", input.memory.fragSeverity === "critical"
+        ? "critical"
+        : input.memory.fragSeverity === "warning" ||
+            input.memory.usagePercent >= constants_1.THRESHOLDS.memory.usageWarning
+            ? "high"
+            : "low", input.memory.recommendations));
+    recommendations.push(...toRecommendations("hit-rate", input.hitRate.hitRate < constants_1.THRESHOLDS.hitRate.critical
+        ? "critical"
+        : input.hitRate.hitRate < constants_1.THRESHOLDS.hitRate.warning ||
+            input.hitRate.evictedKeys > 0
+            ? "high"
+            : "low", input.hitRate.recommendations));
+    recommendations.push(...toRecommendations("persistence", mapSeverity(input.persistence.severity), input.persistence.recommendations));
+    recommendations.push(...toRecommendations("replication", mapSeverity(input.replication.severity), input.replication.recommendations));
+    if (input.metrics.rejectedConnections > 0) {
+        recommendations.push({
+            priority: "high",
+            category: "connections",
+            message: `${input.metrics.rejectedConnections.toLocaleString()} rejected connections detected.`,
+            action: "Raise maxclients, inspect client churn, or add connection pooling.",
+        });
+    }
+    if (input.metrics.blockedClients > 0) {
+        recommendations.push({
+            priority: "medium",
+            category: "connections",
+            message: `${input.metrics.blockedClients.toLocaleString()} blocked clients detected.`,
+            action: "Inspect blocking Lua scripts, transactions, or slow commands.",
+        });
+    }
+    return recommendations.sort((left, right) => PRIORITY_ORDER[left.priority] - PRIORITY_ORDER[right.priority]);
+}
+function toRecommendations(category, priority, items) {
+    return items.map((message) => ({ priority, category, message }));
+}
+function mapSeverity(severity) {
+    if (severity === "critical") {
+        return "critical";
+    }
+    if (severity === "warning") {
+        return "high";
+    }
+    return "low";
+}

package/dist/src/interactive/display.d.ts

@@ -0,0 +1,13 @@
+import type { FullRedisReport, HitRateAnalysis, KeyspaceInfo, MemoryAnalysis, PersistenceAnalysis, RedisInfo, ReplicationAnalysis, SlowCommandAnalysis } from "../types";
+export declare function showFullReport(report: FullRedisReport): void;
+export declare function showHealth(report: FullRedisReport): void;
+export declare function showServerInfo(info: RedisInfo): void;
+export declare function showMemory(analysis: MemoryAnalysis): void;
+export declare function showHitRate(analysis: HitRateAnalysis): void;
+export declare function showSlowCommands(analysis: SlowCommandAnalysis): void;
+export declare function showKeyspaces(keyspaces: KeyspaceInfo[]): void;
+export declare function showConnections(info: RedisInfo): void;
+export declare function showPersistence(analysis: PersistenceAnalysis): void;
+export declare function showReplication(analysis: ReplicationAnalysis): void;
+export declare function showConfig(config: Record<string, string>): void;
+//# sourceMappingURL=display.d.ts.map

package/dist/src/interactive/display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../../../src/interactive/display.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,eAAe,EACf,eAAe,EACf,YAAY,EACZ,cAAc,EACd,mBAAmB,EACnB,SAAS,EACT,mBAAmB,EACnB,mBAAmB,EACnB,MAAM,UAAU,CAAC;AAiBlB,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAY5D;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAWxD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAQpD;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,CAWzD;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAW3D;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAWpE;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,IAAI,CAa7D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAQrD;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAanE;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAUnE;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAK/D"}

package/dist/src/interactive/display.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showFullReport = showFullReport;
+exports.showHealth = showHealth;
+exports.showServerInfo = showServerInfo;
+exports.showMemory = showMemory;
+exports.showHitRate = showHitRate;
+exports.showSlowCommands = showSlowCommands;
+exports.showKeyspaces = showKeyspaces;
+exports.showConnections = showConnections;
+exports.showPersistence = showPersistence;
+exports.showReplication = showReplication;
+exports.showConfig = showConfig;
+const format_1 = require("../utils/format");
+const print_1 = require("../utils/print");
+function showFullReport(report) {
+    showHealth(report);
+    (0, print_1.printSeparator)();
+    showMemory(report.memory);
+    (0, print_1.printSeparator)();
+    showHitRate(report.hitRate);
+    (0, print_1.printSeparator)();
+    showPersistence(report.persistence);
+    (0, print_1.printSeparator)();
+    showReplication(report.replication);
+    (0, print_1.printSeparator)();
+    showSlowCommands(report.slowCommands);
+}
+function showHealth(report) {
+    (0, print_1.printSection)("Health");
+    (0, print_1.printRow)("Health score", `${report.healthScore}/100 ${(0, print_1.healthEmoji)(report.healthScore)} ${(0, print_1.healthLabel)(report.healthScore)}`);
+    (0, print_1.printRow)("Redis version", report.metrics.version);
+    (0, print_1.printRow)("Mode", report.metrics.mode);
+    (0, print_1.printRow)("Used memory", report.memory.usedMemoryHuman);
+    (0, print_1.printRow)("Hit rate", (0, format_1.formatPercent)(report.hitRate.hitRate));
+    (0, print_1.printRow)("Ops / sec", (0, format_1.formatNumber)(report.metrics.opsPerSec));
+}
+function showServerInfo(info) {
+    (0, print_1.printSection)("Server Info");
+    (0, print_1.printRow)("Version", info.redisVersion);
+    (0, print_1.printRow)("Mode", info.redisMode);
+    (0, print_1.printRow)("OS", info.os);
+    (0, print_1.printRow)("Uptime", `${info.uptimeInDays} days`);
+    (0, print_1.printRow)("Port", info.tcpPort);
+    (0, print_1.printRow)("Config file", info.configFile || "n/a");
+}
+function showMemory(analysis) {
+    (0, print_1.printSection)("Memory");
+    (0, print_1.printRow)("Used", analysis.usedMemoryHuman);
+    (0, print_1.printRow)("Max", analysis.maxMemoryHuman || "unlimited");
+    (0, print_1.printRow)("Usage", (0, format_1.formatPercent)(analysis.usagePercent));
+    (0, print_1.printRow)("Fragmentation", analysis.fragRatio.toFixed(2));
+    (0, print_1.printRow)("Fragmentation waste", (0, format_1.formatBytes)(analysis.fragBytes));
+    (0, print_1.printRow)("RSS overhead", (0, format_1.formatBytes)(analysis.rssOverhead));
+    for (const recommendation of analysis.recommendations) {
+        (0, print_1.printBullet)(recommendation);
+    }
+}
+function showHitRate(analysis) {
+    (0, print_1.printSection)("Hit Rate");
+    (0, print_1.printRow)("Hits", (0, format_1.formatNumber)(analysis.hits));
+    (0, print_1.printRow)("Misses", (0, format_1.formatNumber)(analysis.misses));
+    (0, print_1.printRow)("Hit rate", (0, format_1.formatPercent)(analysis.hitRate));
+    (0, print_1.printRow)("Evicted keys", (0, format_1.formatNumber)(analysis.evictedKeys));
+    (0, print_1.printRow)("Expired keys", (0, format_1.formatNumber)(analysis.expiredKeys));
+    (0, print_1.printRow)("Policy", analysis.evictionPolicy);
+    for (const recommendation of analysis.recommendations) {
+        (0, print_1.printBullet)(recommendation);
+    }
+}
+function showSlowCommands(analysis) {
+    (0, print_1.printSection)("Slow Commands");
+    (0, print_1.printRow)("Logged entries", (0, format_1.formatNumber)(analysis.totalLogged));
+    (0, print_1.printRow)("Threshold", (0, format_1.formatDuration)(analysis.threshold / 1000));
+    for (const command of analysis.topCommandTypes) {
+        (0, print_1.printBullet)(`${command.command} — ${(0, format_1.formatNumber)(command.count)} entries`);
+        (0, print_1.printSubBullet)(`Average duration: ${(0, format_1.formatDuration)(command.avgMs)}`);
+    }
+    for (const recommendation of analysis.recommendations) {
+        (0, print_1.printBullet)(recommendation);
+    }
+}
+function showKeyspaces(keyspaces) {
+    (0, print_1.printSection)("Keyspaces");
+    if (keyspaces.length === 0) {
+        console.log("  No keys found.");
+        return;
+    }
+    for (const keyspace of keyspaces) {
+        (0, print_1.printBullet)(`db${keyspace.db} — ${(0, format_1.formatNumber)(keyspace.keys)} keys`);
+        (0, print_1.printSubBullet)(`Expiring: ${(0, format_1.formatNumber)(keyspace.expires)} | Avg TTL: ${(0, format_1.formatDuration)(keyspace.avgTtl)}`);
+    }
+}
+function showConnections(info) {
+    (0, print_1.printSection)("Connections");
+    (0, print_1.printRow)("Connected clients", (0, format_1.formatNumber)(info.connectedClients));
+    (0, print_1.printRow)("Blocked clients", (0, format_1.formatNumber)(info.blockedClients));
+    (0, print_1.printRow)("Max clients", (0, format_1.formatNumber)(info.maxClients));
+    (0, print_1.printRow)("Rejected connections", (0, format_1.formatNumber)(info.rejectedConnections));
+    (0, print_1.printRow)("Max input buffer", (0, format_1.formatBytes)(info.clientRecentMaxInputBuffer));
+    (0, print_1.printRow)("Max output buffer", (0, format_1.formatBytes)(info.clientRecentMaxOutputBuffer));
+}
+function showPersistence(analysis) {
+    (0, print_1.printSection)("Persistence");
+    (0, print_1.printRow)("RDB enabled", analysis.rdb.enabled ? "yes" : "no");
+    (0, print_1.printRow)("RDB last status", analysis.rdb.lastStatus);
+    (0, print_1.printRow)("Seconds since save", (0, format_1.formatNumber)(analysis.rdb.secondsSinceLastSave));
+    (0, print_1.printRow)("AOF enabled", analysis.aof.enabled ? "yes" : "no");
+    (0, print_1.printRow)("AOF last status", analysis.aof.lastStatus);
+    for (const recommendation of analysis.recommendations) {
+        (0, print_1.printBullet)(recommendation);
+    }
+}
+function showReplication(analysis) {
+    (0, print_1.printSection)("Replication");
+    (0, print_1.printRow)("Role", analysis.role);
+    (0, print_1.printRow)("Connected replicas", (0, format_1.formatNumber)(analysis.connectedSlaves));
+    (0, print_1.printRow)("Link status", analysis.linkStatus ?? "n/a");
+    (0, print_1.printRow)("Lag seconds", analysis.lagSeconds ?? "n/a");
+    (0, print_1.printRow)("Sync in progress", analysis.syncInProgress ? "yes" : "no");
+    for (const recommendation of analysis.recommendations) {
+        (0, print_1.printBullet)(recommendation);
+    }
+}
+function showConfig(config) {
+    (0, print_1.printSection)("Configuration");
+    for (const [key, value] of Object.entries(config)) {
+        (0, print_1.printRow)(key, value);
+    }
+}

package/dist/src/interactive/index.d.ts

@@ -0,0 +1,23 @@
+import type { Redis } from "ioredis";
+import type { ParsedOptions } from "../cli/options";
+import type { RedisConnection } from "../types";
+export declare class InteractiveCLI {
+    private readonly client;
+    private readonly connection;
+    private readonly runtimeOptions;
+    private readonly collector;
+    private readonly memory;
+    private readonly performance;
+    private readonly persistence;
+    private readonly replication;
+    constructor(client: Redis, connection: RedisConnection, runtimeOptions: ParsedOptions);
+    start(): Promise<void>;
+    private reporter;
+    private analysisMenu;
+    private singleModuleMenu;
+    private runModule;
+    private reportsMenu;
+    private watchMenu;
+    private settingsMenu;
+}
+//# sourceMappingURL=index.d.ts.map