tusktsk/cli/commands/cache.js

TuskTsk - The Freedom Configuration Language. Query databases, use any syntax, never bow to any king!

/**
 * Cache Commands for TuskLang CLI
 * ================================
 * Implements cache operations
 */

const { Command } = require('commander');
const fs = require('fs').promises;
const path = require('path');

// Cache clear command
const clear = new Command('clear')
  .description('Clear all caches')
  .action(async () => {
    try {
      console.log('🔄 Clearing all caches...');
      
      // Clear TuskLang parser cache
      const TuskLang = require('../../index.js');
      const tusk = new TuskLang();
      if (tusk.parser.cache) {
        tusk.parser.cache.clear();
        console.log('  ✅ Parser cache cleared');
      }
      
      // Clear PeanutConfig cache
      const PeanutConfig = require('../../peanut-config.js');
      const peanutConfig = new PeanutConfig();
      peanutConfig.cache.clear();
      console.log('  ✅ Configuration cache cleared');
      
      // Clear file system caches
      await clearFileSystemCaches();
      
      console.log('✅ All caches cleared successfully');
      
      return { success: true };
    } catch (error) {
      console.error('❌ Failed to clear caches:', error.message);
      return { success: false, error: error.message };
    }
  });

// Cache status command
const status = new Command('status')
  .description('Show cache status and statistics')
  .action(async () => {
    try {
      console.log('📍 Cache Status and Statistics');
      console.log('===============================');
      
      // Get TuskLang parser cache stats
      const TuskLang = require('../../index.js');
      const tusk = new TuskLang();
      const parserCacheSize = tusk.parser.cache ? tusk.parser.cache.size : 0;
      
      // Get PeanutConfig cache stats
      const PeanutConfig = require('../../peanut-config.js');
      const peanutConfig = new PeanutConfig();
      const configCacheSize = peanutConfig.cache.size;
      
      // Get file system cache stats
      const fsCacheStats = await getFileSystemCacheStats();
      
      console.log('📊 Cache Statistics:');
      console.log(`  Parser Cache: ${parserCacheSize} entries`);
      console.log(`  Config Cache: ${configCacheSize} entries`);
      console.log(`  File System Cache: ${fsCacheStats.files} files, ${fsCacheStats.size} bytes`);
      console.log('');
      
      console.log('💾 Cache Locations:');
      console.log(`  Parser Cache: Memory`);
      console.log(`  Config Cache: Memory`);
      console.log(`  File System Cache: ${fsCacheStats.path}`);
      
      return {
        parser: { size: parserCacheSize },
        config: { size: configCacheSize },
        filesystem: fsCacheStats
      };
    } catch (error) {
      console.error('❌ Failed to get cache status:', error.message);
      return { success: false, error: error.message };
    }
  });

// Cache warm command
const warm = new Command('warm')
  .description('Pre-warm caches')
  .action(async () => {
    try {
      console.log('🔄 Pre-warming caches...');
      
      // Warm PeanutConfig cache
      const PeanutConfig = require('../../peanut-config.js');
      const peanutConfig = new PeanutConfig();
      const config = peanutConfig.load(process.cwd());
      console.log('  ✅ Configuration cache warmed');
      
      // Warm TuskLang parser cache
      const TuskLang = require('../../index.js');
      const tusk = new TuskLang();
      
      // Parse some common configurations
      const commonConfigs = [
        'name: "test"\nversion: "1.0"',
        '[database]\nhost: "localhost"\nport: 5432',
        'server {\n  port: 8080\n}'
      ];
      
      for (const config of commonConfigs) {
        tusk.parse(config);
      }
      console.log('  ✅ Parser cache warmed');
      
      // Warm file system cache
      await warmFileSystemCache();
      console.log('  ✅ File system cache warmed');
      
      console.log('✅ All caches warmed successfully');
      
      return { success: true };
    } catch (error) {
      console.error('❌ Failed to warm caches:', error.message);
      return { success: false, error: error.message };
    }
  });

// Memcached command
const memcached = new Command('memcached')
  .description('Memcached operations')
  .addCommand(new Command('status').description('Check Memcached connection status').action(memcachedStatus))
  .addCommand(new Command('stats').description('Show detailed Memcached statistics').action(memcachedStats))
  .addCommand(new Command('flush').description('Flush all Memcached data').action(memcachedFlush))
  .addCommand(new Command('restart').description('Restart Memcached service').action(memcachedRestart))
  .addCommand(new Command('test').description('Test Memcached connection').action(memcachedTest));

// Memcached subcommands
async function memcachedStatus() {
  try {
    console.log('📍 Checking Memcached connection status...');
    
    // In a real implementation, this would check Memcached connectivity
    // For now, we'll simulate it
    const isConnected = await checkMemcachedConnection();
    
    if (isConnected) {
      console.log('✅ Memcached is running and accessible');
      return { status: 'connected' };
    } else {
      console.log('❌ Memcached is not accessible');
      return { status: 'disconnected' };
    }
  } catch (error) {
    console.error('❌ Failed to check Memcached status:', error.message);
    return { status: 'error', error: error.message };
  }
}

async function memcachedStats() {
  try {
    console.log('📍 Getting Memcached statistics...');
    
    // In a real implementation, this would get Memcached stats
    // For now, we'll return mock data
    const stats = {
      uptime: '2d 5h 30m',
      connections: 15,
      getHits: 1250,
      getMisses: 45,
      setCommands: 320,
      deleteCommands: 12,
      evictions: 0,
      bytesRead: '1.2MB',
      bytesWritten: '856KB'
    };
    
    console.log('📊 Memcached Statistics:');
    console.log(`  Uptime: ${stats.uptime}`);
    console.log(`  Current Connections: ${stats.connections}`);
    console.log(`  Get Hits: ${stats.getHits}`);
    console.log(`  Get Misses: ${stats.getMisses}`);
    console.log(`  Hit Rate: ${((stats.getHits / (stats.getHits + stats.getMisses)) * 100).toFixed(1)}%`);
    console.log(`  Set Commands: ${stats.setCommands}`);
    console.log(`  Delete Commands: ${stats.deleteCommands}`);
    console.log(`  Evictions: ${stats.evictions}`);
    console.log(`  Bytes Read: ${stats.bytesRead}`);
    console.log(`  Bytes Written: ${stats.bytesWritten}`);
    
    return { success: true, stats };
  } catch (error) {
    console.error('❌ Failed to get Memcached stats:', error.message);
    return { success: false, error: error.message };
  }
}

async function memcachedFlush() {
  try {
    console.log('🔄 Flushing all Memcached data...');
    
    // In a real implementation, this would flush Memcached
    // For now, we'll simulate it
    await new Promise(resolve => setTimeout(resolve, 1000));
    
    console.log('✅ All Memcached data flushed successfully');
    return { success: true };
  } catch (error) {
    console.error('❌ Failed to flush Memcached:', error.message);
    return { success: false, error: error.message };
  }
}

async function memcachedRestart() {
  try {
    console.log('🔄 Restarting Memcached service...');
    
    // In a real implementation, this would restart Memcached
    // For now, we'll simulate it
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    console.log('✅ Memcached service restarted successfully');
    return { success: true };
  } catch (error) {
    console.error('❌ Failed to restart Memcached:', error.message);
    return { success: false, error: error.message };
  }
}

async function memcachedTest() {
  try {
    console.log('🔄 Testing Memcached connection...');
    
    // In a real implementation, this would test Memcached connectivity
    // For now, we'll simulate it
    const isConnected = await checkMemcachedConnection();
    
    if (isConnected) {
      console.log('✅ Memcached connection test passed');
      return { success: true, connected: true };
    } else {
      console.log('❌ Memcached connection test failed');
      return { success: false, connected: false };
    }
  } catch (error) {
    console.error('❌ Memcached connection test failed:', error.message);
    return { success: false, error: error.message };
  }
}

// Helper functions
async function clearFileSystemCaches() {
  try {
    // Clear any temporary cache files
    const cacheDir = path.join(process.cwd(), '.cache');
    
    if (await fs.access(cacheDir).then(() => true).catch(() => false)) {
      const files = await fs.readdir(cacheDir);
      for (const file of files) {
        await fs.unlink(path.join(cacheDir, file));
      }
      console.log('  ✅ File system cache cleared');
    }
  } catch (error) {
    console.warn('  ⚠️ Could not clear file system cache:', error.message);
  }
}

async function getFileSystemCacheStats() {
  try {
    const cacheDir = path.join(process.cwd(), '.cache');
    
    if (await fs.access(cacheDir).then(() => true).catch(() => false)) {
      const files = await fs.readdir(cacheDir);
      let totalSize = 0;
      
      for (const file of files) {
        const stats = await fs.stat(path.join(cacheDir, file));
        totalSize += stats.size;
      }
      
      return {
        path: cacheDir,
        files: files.length,
        size: totalSize
      };
    } else {
      return {
        path: cacheDir,
        files: 0,
        size: 0
      };
    }
  } catch (error) {
    return {
      path: 'unknown',
      files: 0,
      size: 0,
      error: error.message
    };
  }
}

async function warmFileSystemCache() {
  try {
    // In a real implementation, this would pre-load commonly accessed files
    // For now, we'll simulate it
    await new Promise(resolve => setTimeout(resolve, 500));
  } catch (error) {
    console.warn('  ⚠️ Could not warm file system cache:', error.message);
  }
}

async function checkMemcachedConnection() {
  try {
    // In a real implementation, this would check Memcached connectivity
    // For now, we'll simulate it
    await new Promise(resolve => setTimeout(resolve, 100));
    
    // Simulate 80% success rate
    return Math.random() > 0.2;
  } catch (error) {
    return false;
  }
}

module.exports = {
  clear,
  status,
  warm,
  memcached
};