lsh-framework 0.5.4

package/dist/cicd/analytics.js

@@ -0,0 +1,261 @@
+import { createClient } from '@supabase/supabase-js';
+import Redis from 'ioredis';
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY;
+const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
+// Future use for Supabase integration - keeping for planned features
+const _supabase = SUPABASE_URL && SUPABASE_ANON_KEY ?
+    createClient(SUPABASE_URL, SUPABASE_ANON_KEY) : null;
+const redis = new Redis(REDIS_URL);
+// Calculate moving average for trend smoothing - utility function for future features
+function _movingAverage(data, window) {
+    const result = [];
+    for (let i = 0; i < data.length; i++) {
+        const start = Math.max(0, i - window + 1);
+        const subset = data.slice(start, i + 1);
+        const avg = subset.reduce((a, b) => a + b, 0) / subset.length;
+        result.push(avg);
+    }
+    return result;
+}
+// Detect anomalies using Z-score
+function detectAnomalies(data, threshold = 2.5) {
+    const mean = data.reduce((a, b) => a + b, 0) / data.length;
+    const variance = data.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / data.length;
+    const stdDev = Math.sqrt(variance);
+    return data.map((value, index) => {
+        const zScore = Math.abs((value - mean) / stdDev);
+        return zScore > threshold ? index : -1;
+    }).filter(index => index !== -1);
+}
+// Linear regression for predictions
+function linearRegression(data) {
+    const n = data.length;
+    const x = Array.from({ length: n }, (_, i) => i);
+    const sumX = x.reduce((a, b) => a + b, 0);
+    const sumY = data.reduce((a, b) => a + b, 0);
+    const sumXY = x.reduce((sum, xi, i) => sum + xi * data[i], 0);
+    const sumX2 = x.reduce((sum, xi) => sum + xi * xi, 0);
+    const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
+    const intercept = (sumY - slope * sumX) / n;
+    return { slope, intercept };
+}
+export async function generateTrendAnalysis(days = 30) {
+    const trends = [];
+    const endDate = new Date();
+    const startDate = new Date();
+    startDate.setDate(endDate.getDate() - days);
+    for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
+        const dateStr = d.toISOString().split('T')[0];
+        const key = `metrics:${dateStr}`;
+        const metrics = await redis.hgetall(key);
+        const durations = await redis.lrange(`durations:${dateStr}`, 0, -1);
+        const totalBuilds = parseInt(metrics.total_builds || '0');
+        const successfulBuilds = parseInt(metrics.successful_builds || '0');
+        const failedBuilds = parseInt(metrics.failed_builds || '0');
+        const avgDuration = durations.length > 0
+            ? durations.reduce((sum, d) => sum + parseInt(d), 0) / durations.length
+            : 0;
+        trends.push({
+            date: dateStr,
+            totalBuilds,
+            successRate: totalBuilds > 0 ? (successfulBuilds / totalBuilds) * 100 : 0,
+            avgDuration: avgDuration / 1000 / 60, // Convert to minutes
+            failureRate: totalBuilds > 0 ? (failedBuilds / totalBuilds) * 100 : 0
+        });
+    }
+    return trends;
+}
+export async function detectBuildAnomalies(trends) {
+    const anomalies = [];
+    // Extract metrics
+    const durations = trends.map(t => t.avgDuration);
+    const failureRates = trends.map(t => t.failureRate);
+    const _buildCounts = trends.map(t => t.totalBuilds);
+    // Detect duration anomalies
+    const durationAnomalies = detectAnomalies(durations);
+    durationAnomalies.forEach(index => {
+        const mean = durations.reduce((a, b) => a + b, 0) / durations.length;
+        const stdDev = Math.sqrt(durations.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / durations.length);
+        anomalies.push({
+            timestamp: trends[index].date,
+            type: 'duration',
+            severity: durations[index] > mean + 3 * stdDev ? 'critical' : 'warning',
+            description: `Build duration significantly higher than average`,
+            value: durations[index],
+            expectedRange: {
+                min: Math.max(0, mean - 2 * stdDev),
+                max: mean + 2 * stdDev
+            }
+        });
+    });
+    // Detect failure rate anomalies
+    const failureAnomalies = detectAnomalies(failureRates, 2);
+    failureAnomalies.forEach(index => {
+        if (failureRates[index] > 20) { // Only flag if failure rate > 20%
+            anomalies.push({
+                timestamp: trends[index].date,
+                type: 'failure_rate',
+                severity: failureRates[index] > 50 ? 'critical' : 'warning',
+                description: `High failure rate detected`,
+                value: failureRates[index],
+                expectedRange: { min: 0, max: 20 }
+            });
+        }
+    });
+    return anomalies;
+}
+export async function generateInsights(trends) {
+    const insights = [];
+    if (trends.length < 7)
+        return insights;
+    // Compare last 7 days with previous 7 days
+    const recentWeek = trends.slice(-7);
+    const previousWeek = trends.slice(-14, -7);
+    const recentAvgSuccess = recentWeek.reduce((sum, t) => sum + t.successRate, 0) / 7;
+    const prevAvgSuccess = previousWeek.reduce((sum, t) => sum + t.successRate, 0) / 7;
+    const successChange = recentAvgSuccess - prevAvgSuccess;
+    if (Math.abs(successChange) > 5) {
+        insights.push({
+            type: successChange > 0 ? 'improvement' : 'degradation',
+            title: `Success Rate ${successChange > 0 ? 'Improved' : 'Degraded'}`,
+            description: `Success rate changed by ${Math.abs(successChange).toFixed(1)}% compared to previous week`,
+            metric: 'success_rate',
+            change: successChange,
+            impact: Math.abs(successChange) > 15 ? 'high' : Math.abs(successChange) > 10 ? 'medium' : 'low'
+        });
+    }
+    // Analyze build duration trends
+    const recentAvgDuration = recentWeek.reduce((sum, t) => sum + t.avgDuration, 0) / 7;
+    const prevAvgDuration = previousWeek.reduce((sum, t) => sum + t.avgDuration, 0) / 7;
+    const durationChange = ((recentAvgDuration - prevAvgDuration) / prevAvgDuration) * 100;
+    if (Math.abs(durationChange) > 10) {
+        insights.push({
+            type: durationChange < 0 ? 'improvement' : 'degradation',
+            title: `Build Duration ${durationChange < 0 ? 'Improved' : 'Increased'}`,
+            description: `Average build duration changed by ${Math.abs(durationChange).toFixed(1)}%`,
+            metric: 'duration',
+            change: durationChange,
+            impact: Math.abs(durationChange) > 30 ? 'high' : Math.abs(durationChange) > 20 ? 'medium' : 'low'
+        });
+    }
+    // Identify patterns
+    const dailyBuilds = trends.map(t => t.totalBuilds);
+    const weekdays = trends.map(t => new Date(t.date).getDay());
+    const weekdayAvg = Array(7).fill(0).map((_, day) => {
+        const dayBuilds = dailyBuilds.filter((_, i) => weekdays[i] === day);
+        return dayBuilds.reduce((a, b) => a + b, 0) / dayBuilds.length;
+    });
+    const peakDay = weekdayAvg.indexOf(Math.max(...weekdayAvg));
+    const lowDay = weekdayAvg.indexOf(Math.min(...weekdayAvg));
+    const dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+    insights.push({
+        type: 'pattern',
+        title: 'Weekly Build Pattern Detected',
+        description: `Most builds occur on ${dayNames[peakDay]}, least on ${dayNames[lowDay]}`,
+        metric: 'frequency',
+        change: 0,
+        impact: 'low'
+    });
+    return insights;
+}
+export async function predictNextPeriod(trends) {
+    const predictions = [];
+    if (trends.length < 14)
+        return predictions;
+    // Predict success rate
+    const successRates = trends.map(t => t.successRate);
+    const successRegression = linearRegression(successRates.slice(-14));
+    const predictedSuccess = successRegression.slope * successRates.length + successRegression.intercept;
+    predictions.push({
+        metric: 'success_rate',
+        nextPeriod: 'next_7_days',
+        predictedValue: Math.max(0, Math.min(100, predictedSuccess)),
+        confidence: 0.75,
+        trend: successRegression.slope > 1 ? 'improving' :
+            successRegression.slope < -1 ? 'degrading' : 'stable'
+    });
+    // Predict build volume
+    const buildCounts = trends.map(t => t.totalBuilds);
+    const volumeRegression = linearRegression(buildCounts.slice(-14));
+    const predictedVolume = volumeRegression.slope * buildCounts.length + volumeRegression.intercept;
+    predictions.push({
+        metric: 'build_volume',
+        nextPeriod: 'next_day',
+        predictedValue: Math.max(0, Math.round(predictedVolume)),
+        confidence: 0.7,
+        trend: volumeRegression.slope > 5 ? 'improving' :
+            volumeRegression.slope < -5 ? 'degrading' : 'stable'
+    });
+    return predictions;
+}
+export async function calculateCostAnalysis(trends) {
+    // Estimate costs based on build minutes (GitHub Actions pricing model)
+    const COST_PER_MINUTE = 0.008; // $0.008 per minute for Linux runners
+    const totalMinutes = trends.reduce((sum, t) => sum + (t.totalBuilds * t.avgDuration), 0);
+    const totalCost = totalMinutes * COST_PER_MINUTE;
+    const totalBuilds = trends.reduce((sum, t) => sum + t.totalBuilds, 0);
+    const savingsOpportunities = [];
+    // Identify savings opportunities
+    const avgDuration = totalMinutes / totalBuilds;
+    if (avgDuration > 10) {
+        savingsOpportunities.push('Consider optimizing long-running builds (>10 minutes average)');
+    }
+    const avgFailureRate = trends.reduce((sum, t) => sum + t.failureRate, 0) / trends.length;
+    if (avgFailureRate > 15) {
+        const wastedCost = (totalCost * avgFailureRate / 100);
+        savingsOpportunities.push(`Reduce failure rate to save ~$${wastedCost.toFixed(2)}/month`);
+    }
+    // Check for off-peak opportunities
+    const peakHourBuilds = trends.filter(t => {
+        const hour = new Date(t.date).getHours();
+        return hour >= 9 && hour <= 17;
+    });
+    if (peakHourBuilds.length > trends.length * 0.7) {
+        savingsOpportunities.push('Schedule non-critical builds during off-peak hours');
+    }
+    return {
+        totalCost,
+        costPerBuild: totalBuilds > 0 ? totalCost / totalBuilds : 0,
+        costByPlatform: {
+            github: totalCost * 0.6, // Estimate based on usage
+            gitlab: totalCost * 0.25,
+            jenkins: totalCost * 0.15
+        },
+        savingsOpportunities
+    };
+}
+export async function generateAnalyticsReport(period = 'weekly') {
+    const days = period === 'daily' ? 1 : period === 'weekly' ? 7 : 30;
+    const trends = await generateTrendAnalysis(days);
+    const [insights, anomalies, predictions, costAnalysis] = await Promise.all([
+        generateInsights(trends),
+        detectBuildAnomalies(trends),
+        predictNextPeriod(trends),
+        calculateCostAnalysis(trends)
+    ]);
+    return {
+        period,
+        startDate: trends[0]?.date || new Date().toISOString(),
+        endDate: trends[trends.length - 1]?.date || new Date().toISOString(),
+        trends,
+        insights,
+        anomalies,
+        predictions,
+        costAnalysis
+    };
+}
+// Export functions for bottleneck detection
+export async function detectBottlenecks() {
+    // Analyze stage durations to find slowest parts
+    const stageData = await redis.hgetall('stage_durations');
+    const bottlenecks = Object.entries(stageData)
+        .map(([stage, duration]) => ({
+        stage,
+        avgDuration: parseInt(duration),
+        impact: 'high'
+    }))
+        .sort((a, b) => b.avgDuration - a.avgDuration)
+        .slice(0, 5);
+    return bottlenecks;
+}

package/dist/cicd/auth.js

@@ -0,0 +1,269 @@
+import jwt from 'jsonwebtoken';
+import bcrypt from 'bcrypt';
+const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key-change-in-production';
+const TOKEN_EXPIRY = '24h';
+export class AuthService {
+    pool;
+    constructor(pool) {
+        this.pool = pool;
+        this.initializeSchema();
+    }
+    async initializeSchema() {
+        const query = `
+      CREATE TABLE IF NOT EXISTS users (
+        id SERIAL PRIMARY KEY,
+        email VARCHAR(255) UNIQUE NOT NULL,
+        name VARCHAR(255) NOT NULL,
+        password_hash VARCHAR(255) NOT NULL,
+        role VARCHAR(50) NOT NULL DEFAULT 'viewer',
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        last_login TIMESTAMP,
+        is_active BOOLEAN DEFAULT true
+      );
+
+      CREATE TABLE IF NOT EXISTS api_keys (
+        id SERIAL PRIMARY KEY,
+        user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+        key_hash VARCHAR(255) UNIQUE NOT NULL,
+        name VARCHAR(255),
+        permissions JSONB,
+        last_used TIMESTAMP,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        expires_at TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS audit_logs (
+        id SERIAL PRIMARY KEY,
+        user_id INTEGER REFERENCES users(id),
+        action VARCHAR(255) NOT NULL,
+        resource VARCHAR(255),
+        details JSONB,
+        ip_address VARCHAR(45),
+        user_agent TEXT,
+        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_audit_logs_user ON audit_logs(user_id);
+      CREATE INDEX IF NOT EXISTS idx_audit_logs_timestamp ON audit_logs(timestamp);
+    `;
+        try {
+            await this.pool.query(query);
+        }
+        catch (error) {
+            console.error('Error initializing auth schema:', error);
+        }
+    }
+    async register(email, password, name, role = 'viewer') {
+        const passwordHash = await bcrypt.hash(password, 10);
+        const query = `
+      INSERT INTO users (email, name, password_hash, role)
+      VALUES ($1, $2, $3, $4)
+      RETURNING id, email, name, role, created_at
+    `;
+        try {
+            const result = await this.pool.query(query, [email, name, passwordHash, role]);
+            return result.rows[0];
+        }
+        catch (error) {
+            if (error.code === '23505') { // Unique constraint violation
+                throw new Error('User with this email already exists');
+            }
+            throw error;
+        }
+    }
+    async login(email, password) {
+        const query = `
+      SELECT id, email, name, role, password_hash, created_at
+      FROM users
+      WHERE email = $1 AND is_active = true
+    `;
+        const result = await this.pool.query(query, [email]);
+        if (result.rows.length === 0) {
+            throw new Error('Invalid credentials');
+        }
+        const user = result.rows[0];
+        const isValid = await bcrypt.compare(password, user.password_hash);
+        if (!isValid) {
+            throw new Error('Invalid credentials');
+        }
+        // Update last login
+        await this.pool.query('UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = $1', [user.id]);
+        const token = this.generateToken(user);
+        delete user.password_hash;
+        return { user, token };
+    }
+    generateToken(user) {
+        const payload = {
+            userId: user.id,
+            email: user.email,
+            role: user.role
+        };
+        return jwt.sign(payload, JWT_SECRET, { expiresIn: TOKEN_EXPIRY });
+    }
+    verifyToken(token) {
+        try {
+            return jwt.verify(token, JWT_SECRET);
+        }
+        catch (_error) {
+            throw new Error('Invalid or expired token');
+        }
+    }
+    async generateApiKey(userId, name, permissions) {
+        const apiKey = this.generateRandomKey();
+        const keyHash = await bcrypt.hash(apiKey, 10);
+        const query = `
+      INSERT INTO api_keys (user_id, key_hash, name, permissions)
+      VALUES ($1, $2, $3, $4)
+      RETURNING id
+    `;
+        await this.pool.query(query, [userId, keyHash, name, permissions || {}]);
+        return apiKey;
+    }
+    generateRandomKey() {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let key = 'cicd_';
+        for (let i = 0; i < 32; i++) {
+            key += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return key;
+    }
+    async verifyApiKey(apiKey) {
+        const query = `
+      SELECT ak.*, u.email, u.role
+      FROM api_keys ak
+      JOIN users u ON ak.user_id = u.id
+      WHERE u.is_active = true
+      AND (ak.expires_at IS NULL OR ak.expires_at > CURRENT_TIMESTAMP)
+    `;
+        const result = await this.pool.query(query);
+        for (const row of result.rows) {
+            const isValid = await bcrypt.compare(apiKey, row.key_hash);
+            if (isValid) {
+                // Update last used
+                await this.pool.query('UPDATE api_keys SET last_used = CURRENT_TIMESTAMP WHERE id = $1', [row.id]);
+                return {
+                    userId: row.user_id,
+                    email: row.email,
+                    role: row.role
+                };
+            }
+        }
+        return null;
+    }
+    async logAudit(userId, action, resource, details, req) {
+        const query = `
+      INSERT INTO audit_logs (user_id, action, resource, details, ip_address, user_agent)
+      VALUES ($1, $2, $3, $4, $5, $6)
+    `;
+        const ipAddress = req?.ip || req?.socket?.remoteAddress;
+        const userAgent = req?.headers['user-agent'];
+        await this.pool.query(query, [
+            userId,
+            action,
+            resource,
+            details || {},
+            ipAddress,
+            userAgent
+        ]);
+    }
+}
+// Middleware for authentication
+export function authenticate(authService) {
+    return async (req, res, next) => {
+        try {
+            const authHeader = req.headers.authorization;
+            if (!authHeader) {
+                return res.status(401).json({ error: 'No authorization header' });
+            }
+            let user = null;
+            if (authHeader.startsWith('Bearer ')) {
+                // JWT token authentication
+                const token = authHeader.substring(7);
+                user = authService.verifyToken(token);
+            }
+            else if (authHeader.startsWith('ApiKey ')) {
+                // API key authentication
+                const apiKey = authHeader.substring(7);
+                user = await authService.verifyApiKey(apiKey);
+            }
+            if (!user) {
+                return res.status(401).json({ error: 'Invalid authentication credentials' });
+            }
+            req.user = user;
+            next();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Authentication failed';
+            return res.status(401).json({ error: message });
+        }
+    };
+}
+// Role-based access control middleware
+export function authorize(...allowedRoles) {
+    return (req, res, next) => {
+        if (!req.user) {
+            return res.status(401).json({ error: 'Authentication required' });
+        }
+        if (!allowedRoles.includes(req.user.role)) {
+            return res.status(403).json({ error: 'Insufficient permissions' });
+        }
+        next();
+    };
+}
+// Permission-based middleware
+export function requirePermission(permission) {
+    return (req, res, next) => {
+        if (!req.user) {
+            return res.status(401).json({ error: 'Authentication required' });
+        }
+        // Admin has all permissions
+        if (req.user.role === 'admin') {
+            return next();
+        }
+        // Check specific permissions based on role
+        const rolePermissions = {
+            developer: [
+                'pipelines.view',
+                'pipelines.trigger',
+                'metrics.view',
+                'analytics.view',
+                'alerts.view'
+            ],
+            viewer: [
+                'pipelines.view',
+                'metrics.view',
+                'analytics.view'
+            ]
+        };
+        const userPermissions = rolePermissions[req.user.role] || [];
+        if (!userPermissions.includes(permission)) {
+            return res.status(403).json({ error: `Permission '${permission}' required` });
+        }
+        next();
+    };
+}
+export function rateLimit(options) {
+    const requests = new Map();
+    return (req, res, next) => {
+        const key = req.user?.userId?.toString() || req.ip || 'anonymous';
+        const now = Date.now();
+        const record = requests.get(key);
+        if (!record || now > record.resetTime) {
+            requests.set(key, {
+                count: 1,
+                resetTime: now + options.windowMs
+            });
+            return next();
+        }
+        if (record.count >= options.max) {
+            const retryAfter = Math.ceil((record.resetTime - now) / 1000);
+            res.setHeader('Retry-After', retryAfter);
+            return res.status(429).json({
+                error: 'Too many requests',
+                retryAfter
+            });
+        }
+        record.count++;
+        next();
+    };
+}

package/dist/cicd/cache-manager.js

@@ -0,0 +1,172 @@
+import Redis from 'ioredis';
+import { createHash } from 'crypto';
+export class CacheManager {
+    redis;
+    stats;
+    defaultTTL;
+    keyPrefix;
+    constructor(redisUrl = 'redis://localhost:6379', options = {}) {
+        this.redis = new Redis(redisUrl);
+        this.defaultTTL = options.ttl || 3600; // 1 hour default
+        this.keyPrefix = options.prefix || 'cicd:cache:';
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            sets: 0,
+            deletes: 0,
+            size: 0,
+            hitRate: 0
+        };
+        // Set up error handling
+        this.redis.on('error', (err) => {
+            console.error('Redis cache error:', err);
+        });
+    }
+    generateKey(namespace, identifier) {
+        const hash = createHash('md5').update(identifier).digest('hex');
+        return `${this.keyPrefix}${namespace}:${hash}`;
+    }
+    async get(namespace, identifier) {
+        const key = this.generateKey(namespace, identifier);
+        try {
+            const cached = await this.redis.get(key);
+            if (cached) {
+                this.stats.hits++;
+                this.updateHitRate();
+                return JSON.parse(cached);
+            }
+            this.stats.misses++;
+            this.updateHitRate();
+            return null;
+        }
+        catch (error) {
+            console.error(`Cache get error for ${key}:`, error);
+            return null;
+        }
+    }
+    async set(namespace, identifier, value, ttl) {
+        const key = this.generateKey(namespace, identifier);
+        const ttlSeconds = ttl || this.defaultTTL;
+        try {
+            const serialized = JSON.stringify(value);
+            await this.redis.setex(key, ttlSeconds, serialized);
+            this.stats.sets++;
+            this.stats.size = await this.getSize();
+        }
+        catch (error) {
+            console.error(`Cache set error for ${key}:`, error);
+        }
+    }
+    async invalidate(namespace, identifier) {
+        try {
+            if (identifier) {
+                // Invalidate specific item
+                const key = this.generateKey(namespace, identifier);
+                await this.redis.del(key);
+                this.stats.deletes++;
+            }
+            else {
+                // Invalidate entire namespace
+                const pattern = `${this.keyPrefix}${namespace}:*`;
+                const keys = await this.redis.keys(pattern);
+                if (keys.length > 0) {
+                    await this.redis.del(...keys);
+                    this.stats.deletes += keys.length;
+                }
+            }
+            this.stats.size = await this.getSize();
+        }
+        catch (error) {
+            console.error(`Cache invalidate error:`, error);
+        }
+    }
+    async getOrSet(namespace, identifier, factory, ttl) {
+        // Try to get from cache first
+        const cached = await this.get(namespace, identifier);
+        if (cached !== null) {
+            return cached;
+        }
+        // Generate fresh value
+        const value = await factory();
+        await this.set(namespace, identifier, value, ttl);
+        return value;
+    }
+    async warmup(namespace, items) {
+        const promises = items.map(async (item) => {
+            await this.getOrSet(namespace, item.id, item.factory, item.ttl);
+        });
+        await Promise.all(promises);
+    }
+    updateHitRate() {
+        const total = this.stats.hits + this.stats.misses;
+        this.stats.hitRate = total > 0 ? (this.stats.hits / total) * 100 : 0;
+    }
+    async getSize() {
+        try {
+            const info = await this.redis.info('memory');
+            const match = info.match(/used_memory_human:(.+)/);
+            if (match) {
+                const size = match[1].trim();
+                // Convert to bytes
+                if (size.endsWith('K'))
+                    return parseFloat(size) * 1024;
+                if (size.endsWith('M'))
+                    return parseFloat(size) * 1024 * 1024;
+                if (size.endsWith('G'))
+                    return parseFloat(size) * 1024 * 1024 * 1024;
+                return parseFloat(size);
+            }
+            return 0;
+        }
+        catch (_error) {
+            return 0;
+        }
+    }
+    async getStats() {
+        this.stats.size = await this.getSize();
+        return { ...this.stats };
+    }
+    async clear() {
+        try {
+            const pattern = `${this.keyPrefix}*`;
+            const keys = await this.redis.keys(pattern);
+            if (keys.length > 0) {
+                await this.redis.del(...keys);
+            }
+            this.resetStats();
+        }
+        catch (error) {
+            console.error('Cache clear error:', error);
+        }
+    }
+    resetStats() {
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            sets: 0,
+            deletes: 0,
+            size: 0,
+            hitRate: 0
+        };
+    }
+    async disconnect() {
+        await this.redis.quit();
+    }
+}
+// Decorator for method-level caching
+export function Cacheable(namespace, ttl) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            const cacheManager = this.cacheManager;
+            if (!cacheManager) {
+                return originalMethod.apply(this, args);
+            }
+            const identifier = `${propertyKey}:${JSON.stringify(args)}`;
+            return cacheManager.getOrSet(namespace, identifier, () => originalMethod.apply(this, args), ttl);
+        };
+        return descriptor;
+    };
+}
+// Export singleton instance
+export const cacheManager = new CacheManager();