i18ntk 2.3.8 → 2.5.0

package/utils/path-utils.js

@@ -1,33 +0,0 @@
-const path = require('path');
-
-function isWindows(p) {
-  return /^[a-zA-Z]:\\/.test(p);
-}
-
-/**
- * Convert an absolute path to a relative path using forward slashes.
- * Works with both Windows and POSIX style paths.
- * @param {string} base - Base directory
- * @param {string} target - Target path
- * @returns {string} Relative path
- */
-function toRelative(base, target) {
-  const rel = isWindows(base) || isWindows(target)
-    ? path.win32.relative(base, target)
-    : path.posix.relative(base, target);
-  return rel.split(/[\\/]/).join('/');
-}
-
-/**
- * Resolve an array of paths against a base directory.
- * Handles both Windows and POSIX style paths.
- * @param {string} base - Base directory
- * @param {string[]} paths - Paths to resolve
- * @returns {string[]} Resolved absolute paths
- */
-function resolvePaths(base, paths) {
-  const resolver = isWindows(base) ? path.win32.resolve : path.posix.resolve;
-  return paths.map(p => resolver(base, p));
-}
-
-module.exports = { toRelative, resolvePaths };

package/utils/performance-optimizer.js

@@ -1,246 +0,0 @@
-/**
- * Ultra-Performance Optimizer
- * Advanced performance tuning utilities for i18n toolkit
- * Targets sub-40ms processing for 200k keys with <10MB memory
- */
-
-const os = require('os');
-const fs = require('fs');
-const path = require('path');
-
-class UltraPerformanceOptimizer {
-  constructor() {
-    this.cpuCores = os.cpus().length;
-    this.totalMemory = os.totalmem();
-    this.availableMemory = this.totalMemory * 0.8; // Use 80% of system memory
-    this.optimalSettings = this.calculateOptimalSettings();
-  }
-
-  /**
-   * Calculate optimal settings based on system resources
-   * @returns {Object} Optimized configuration
-   */
-  calculateOptimalSettings() {
-    const memoryPerKey = 50; // bytes per key (very aggressive)
-    const maxKeysInMemory = Math.floor(this.availableMemory / memoryPerKey);
-    
-    return {
-      batchSize: Math.min(2000, Math.floor(maxKeysInMemory / 100)),
-      concurrency: Math.min(this.cpuCores * 2, 32),
-      memoryLimit: Math.floor(this.availableMemory / 1024 / 1024 * 0.7),
-      bufferSize: 64 * 1024,
-      cacheStrategy: 'lru',
-      compression: 'brotli',
-      streaming: true,
-      parallelProcessing: true,
-      aggressiveGC: true,
-      validateOnLoad: false,
-      validateOnSave: false,
-      skipBackup: true,
-      minimalLogging: true
-    };
-  }
-
-  /**
-   * Generate ultra-performance configuration
-   * @returns {Object} Ultra-performance config
-   */
-  generateUltraConfig() {
-    return {
-      processing: {
-        mode: 'ultra-extreme',
-        batchSize: this.optimalSettings.batchSize,
-        concurrency: this.optimalSettings.concurrency,
-        timeout: 5000,
-        retryAttempts: 0,
-        retryDelay: 0,
-        maxFileSize: 1024 * 1024, // 1MB max files
-        validateOnSave: false,
-        validateOnLoad: false,
-        cacheEnabled: true,
-        cacheTTL: 300000, // 5 minutes
-        autoBackup: false,
-        fileFilter: "**/*.json",
-        memoryLimit: `${this.optimalSettings.memoryLimit}MB`,
-        garbageCollection: true,
-        gcInterval: 500
-      },
-      optimization: {
-        memoryLimit: `${this.optimalSettings.memoryLimit}MB`,
-        localeOptimizer: true,
-        compression: this.optimalSettings.compression,
-        parallelProcessing: this.optimalSettings.parallelProcessing,
-        streaming: this.optimalSettings.streaming,
-        bufferSize: this.optimalSettings.bufferSize,
-        aggressiveGC: this.optimalSettings.aggressiveGC,
-        minimalLogging: this.optimalSettings.minimalLogging
-      },
-      filesystem: {
-        concurrentReads: this.optimalSettings.concurrency,
-        bufferSize: this.optimalSettings.bufferSize,
-        cacheDirectory: '.cache-ultra',
-        tempDirectory: '.tmp-ultra',
-        cleanupInterval: 30000,
-        compression: this.optimalSettings.compression
-      }
-    };
-  }
-
-  /**
-   * Apply memory-efficient processing strategies
-   * @param {Array} keys - Translation keys to process
-   * @param {Function} processor - Processing function
-   * @returns {Promise<Array>} Processed results
-   */
-  async processWithMemoryEfficiency(keys, processor) {
-    const batchSize = this.optimalSettings.batchSize;
-    const results = [];
-    
-    for (let i = 0; i < keys.length; i += batchSize) {
-      const batch = keys.slice(i, i + batchSize);
-      const batchResults = await this.processBatch(batch, processor);
-      results.push(...batchResults);
-      
-      // Aggressive memory management
-      if (global.gc && i % (batchSize * 10) === 0) {
-        global.gc();
-      }
-    }
-    
-    return results;
-  }
-
-  /**
-   * Process a single batch with parallel execution
-   * @param {Array} batch - Batch of keys
-   * @param {Function} processor - Processing function
-   * @returns {Promise<Array>} Batch results
-   */
-  async processBatch(batch, processor) {
-    const chunkSize = Math.ceil(batch.length / this.optimalSettings.concurrency);
-    const chunks = [];
-    
-    for (let i = 0; i < batch.length; i += chunkSize) {
-      chunks.push(batch.slice(i, i + chunkSize));
-    }
-    
-    const promises = chunks.map(chunk => this.processChunk(chunk, processor));
-    const results = await Promise.all(promises);
-    return results.flat();
-  }
-
-  /**
-   * Process a chunk of keys
-   * @param {Array} chunk - Chunk of keys
-   * @param {Function} processor - Processing function
-   * @returns {Promise<Array>} Chunk results
-   */
-  async processChunk(chunk, processor) {
-    return chunk.map(processor);
-  }
-
-  /**
-   * Generate performance report
-   * @param {Object} metrics - Performance metrics
-   * @returns {Object} Formatted report
-   */
-  generateReport(metrics) {
-    return {
-      timestamp: new Date().toISOString(),
-      system: {
-        cpuCores: this.cpuCores,
-        totalMemory: `${Math.floor(this.totalMemory / 1024 / 1024)}MB`,
-        platform: os.platform(),
-        nodeVersion: process.version
-      },
-      optimization: {
-        batchSize: this.optimalSettings.batchSize,
-        concurrency: this.optimalSettings.concurrency,
-        memoryLimit: this.optimalSettings.memoryLimit,
-        compression: this.optimalSettings.compression
-      },
-      performance: {
-        processingTime: metrics.processingTime,
-        memoryUsage: metrics.memoryUsage,
-        throughput: metrics.throughput,
-        efficiency: metrics.efficiency
-      },
-      recommendations: this.generateRecommendations(metrics)
-    };
-  }
-
-  /**
-   * Generate performance recommendations
-   * @param {Object} metrics - Performance metrics
-   * @returns {Array} Recommendations
-   */
-  generateRecommendations(metrics) {
-    const recommendations = [];
-    
-    if (metrics.processingTime > 40) {
-      recommendations.push('Consider reducing batch size for better memory locality');
-    }
-    
-    if (metrics.memoryUsage > 15) {
-      recommendations.push('Enable more aggressive garbage collection');
-    }
-    
-    if (metrics.throughput < 4000000) {
-      recommendations.push('Increase concurrency if CPU cores available');
-    }
-    
-    return recommendations;
-  }
-
-  /**
-   * Benchmark current system capabilities
-   * @returns {Promise<Object>} Benchmark results
-   */
-  async benchmarkSystem() {
-    const testKeys = Array.from({ length: 10000 }, (_, i) => `key_${i}`);
-    const startTime = process.hrtime.bigint();
-    const startMemory = process.memoryUsage();
-    
-    const results = await this.processWithMemoryEfficiency(testKeys, key => ({
-      key,
-      processed: true,
-      timestamp: Date.now()
-    }));
-    
-    const endTime = process.hrtime.bigint();
-    const endMemory = process.memoryUsage();
-    
-    const processingTime = Number(endTime - startTime) / 1000000; // Convert to ms
-    const memoryDelta = (endMemory.heapUsed - startMemory.heapUsed) / 1024 / 1024;
-    const throughput = testKeys.length / (processingTime / 1000);
-    
-    return {
-      processingTime,
-      memoryUsage: Math.max(0, memoryDelta),
-      throughput,
-      efficiency: testKeys.length / processingTime * 1000
-    };
-  }
-}
-
-module.exports = UltraPerformanceOptimizer;
-
-// CLI usage
-if (require.main === module) {
-  const optimizer = new UltraPerformanceOptimizer();
-  optimizer.benchmarkSystem().then(metrics => {
-    const report = optimizer.generateReport(metrics);
-    console.log('🚀 Ultra-Performance Analysis');
-    console.log('================================');
-    console.log(`Processing Time: ${metrics.processingTime.toFixed(2)}ms`);
-    console.log(`Memory Usage: ${metrics.memoryUsage.toFixed(2)}MB`);
-    console.log(`Throughput: ${(metrics.throughput / 1000000).toFixed(2)}M keys/sec`);
-    console.log(`Efficiency: ${metrics.efficiency.toFixed(0)} keys/ms`);
-    
-    console.log('\n⚙️  Optimal Settings:');
-    console.log(JSON.stringify(optimizer.optimalSettings, null, 2));
-    
-    console.log('\n📊 Recommendations:');
-    report.recommendations.forEach(rec => console.log(`- ${rec}`));
-  });
-}

package/utils/prompt-new.js

@@ -1,55 +0,0 @@
-const readline = require('readline');
-const { logger } = require('./logger');
-
-class Prompt {
-  constructor() {
-    this.rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-  }
-
-  close() {
-    this.rl.close();
-  }
-
-  async question(questionText) {
-    return new Promise((resolve) => {
-      this.rl.question(questionText, (answer) => {
-        resolve(answer.trim());
-      });
-    });
-  }
-
-  async confirm(questionText, defaultValue = false) {
-    const answer = await this.question(`${questionText} (${defaultValue ? 'Y/n' : 'y/N'}) `);
-    if (answer === '') return defaultValue;
-    return /^y|yes$/i.test(answer);
-  }
-
-  async select(questionText, choices, defaultIndex = 0) {
-    logger.log(`\n${questionText}:`);
-    choices.forEach((choice, index) => {
-      logger.log(`  ${index + 1}. ${choice}`);
-    });
-
-    while (true) {
-      const answer = await this.question(`\nSelect an option (1-${choices.length}): `);
-      const selected = parseInt(answer, 10) - 1;
-      if (!isNaN(selected) && selected >= 0 && selected < choices.length) {
-        return selected;
-      }
-      logger.log('Invalid selection. Please try again.');
-    }
-  }
-
-  async input(questionText, defaultValue = '') {
-    const answer = await this.question(`${questionText}${defaultValue ? ` [${defaultValue}]` : ''}: `);
-    return answer || defaultValue;
-  }
-}
-
-const prompt = new Prompt();
-process.on('exit', () => prompt.close());
-
-module.exports = prompt;

package/utils/promptPin.js

@@ -1,76 +0,0 @@
-const readline = require('readline');
-
-async function promptPin({ rl, label = 'Enter 4-digit Admin PIN: ', length = 4, digitsOnly = true } = {}) {
-  return rawMaskedPrompt(rl, label, { length, digitsOnly });
-}
-
-async function promptPinConfirm(rl, label1 = 'Enter new 4-digit Admin PIN: ', label2 = 'Confirm PIN: ') {
-  const pin1 = await promptPin({ rl, label: label1 });
-  const pin2 = await promptPin({ rl, label: label2 });
-  if (pin1 !== pin2) throw new Error('PINs do not match');
-  return pin1;
-}
-
-function rawMaskedPrompt(rl, promptText, { length = 4, digitsOnly = true } = {}) {
-  return new Promise((resolve) => {
-    const input = rl.input;
-    const output = rl.output;
-
-    const isRaw = input.isRaw;
-    if (!isRaw) input.setRawMode && input.setRawMode(true);
-
-    let buf = '';
-
-    const onData = (chunk) => {
-      const s = chunk.toString('utf8');
-
-      if (s === '\r' || s === '\n') {
-        if (buf.length === length) {
-          output.write('\n');
-          cleanup();
-          return resolve(buf);
-        }
-        return;
-      }
-
-      if (s === '\u0003') {
-        output.write('\n');
-        cleanup();
-        process.exit(130);
-      }
-
-      if (s === '\u0008' || s === '\u007f') {
-        if (buf.length > 0) buf = buf.slice(0, -1);
-        repaint();
-        return;
-      }
-
-      const ch = s;
-      if (digitsOnly) {
-        if (/^\d$/.test(ch) && buf.length < length) {
-          buf += ch;
-          repaint();
-        }
-      } else if (buf.length < length) {
-        buf += ch;
-        repaint();
-      }
-    };
-
-    const repaint = () => {
-      output.cursorTo && output.cursorTo(0);
-      output.clearLine && output.clearLine(1);
-      output.write(promptText + '*'.repeat(buf.length));
-    };
-
-    const cleanup = () => {
-      input.removeListener('data', onData);
-      if (!isRaw) input.setRawMode && input.setRawMode(false);
-    };
-
-    output.write(promptText);
-    input.on('data', onData);
-  });
-}
-
-module.exports = { promptPin, promptPinConfirm };

package/utils/safe-json.js

@@ -1,40 +0,0 @@
-// utils/safe-json.js
-const fs = require('fs');
-
-function stripBOM(s) {
-  if (typeof s === 'string' && s.charCodeAt(0) === 0xFEFF) return s.slice(1);
-  return s;
-}
-
-/**
- * Safe JSON load with guardrails.
- * - Max file size (default 1MB)
- * - BOM stripping
- * - Single, typed error (no loops)
- */
-async function readJsonSafe(filePath, { maxBytes = 1_000_000 } = {}) {
-  const buf = await fs.promises.readFile(filePath);
-  if (buf.length === 0) {
-    const err = new Error('Empty JSON file');
-    err.code = 'EJSONEMPTY';
-    err.path = filePath;
-    throw err;
-  }
-  if (buf.length > maxBytes) {
-    const err = new Error(`JSON too large (${buf.length} bytes)`);
-    err.code = 'EJSONTOOBIG';
-    err.path = filePath;
-    throw err;
-  }
-  try {
-    return JSON.parse(stripBOM(buf.toString('utf8')));
-  } catch (e) {
-    const err = new Error(`Invalid JSON`);
-    err.code = 'EJSONPARSE';
-    err.path = filePath;
-    err.cause = e;
-    throw err;
-  }
-}
-
-module.exports = { readJsonSafe };