i18ntk 2.3.7 → 2.4.0

package/utils/logger.js

@@ -1,64 +1,233 @@
-const colors = require('./colors-new');
-const { envManager } = require('./env-manager');
-
-// Enhanced logger with TTY detection and proper stream handling
-const logger = {
-  // Basic log function with color support
-  log: (message, color = '') => {
-    const output = color ? color(message) : message;
-    if (process.stdout.isTTY) {
-      process.stdout.write(output + '\n');
-    } else {
-      console.log(output);
-    }
-  },
-  
-  // Error logging (goes to stderr)
-  error: (message) => {
-    const output = `❌ ${message}`;
-    if (process.stderr.isTTY) {
-      process.stderr.write(colors.bright(colors.red(output)) + '\n');
-    } else {
-      console.error(output);
-    }
-  },
-  
-  // Success logging
-  success: (message) => {
-    const output = `✅ ${message}`;
-    logger.log(output, colors.green);
-  },
-  
-  // Warning logging (goes to stderr)
-  warn: (message) => {
-    const output = `⚠️  ${message}`;
-    if (process.stderr.isTTY) {
-      process.stderr.write(colors.bright(colors.yellow(output)) + '\n');
-    } else {
-      console.warn(output);
-    }
-  },
-  
-  // Info logging
-  info: (message) => {
-    const output = `ℹ️  ${message}`;
-    logger.log(output, colors.blue);
-  },
-  
-  // Debug logging (only when DEBUG env var is set or log level is debug)
-  debug: (message) => {
-    const logLevel = envManager.get('I18NTK_LOG_LEVEL');
-    const debugEnabled = logLevel === 'debug';
-    
-    if (debugEnabled) {
-      const output = `[DEBUG] ${message}`;
-      if (process.stderr.isTTY) {
-        process.stderr.write(colors.gray(output) + '\n');
-      } else {
-        console.debug(output);
-      }
-    }
-  }
-};
-
-module.exports = { colors, logger };
+const colors = require('./colors-new');
+
+const LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+const DEFAULT_INTERNAL_PREFIXES = ['[BUILD]', '[WORKERS]', '[I18N]', '[SECURITY]', '[SUCCESS]', '[WARN]', '[ERROR]', '[INFO]', '[DEBUG]'];
+const FIRST_ERROR_CONTEXT = new Map();
+
+function asBoolean(value) {
+  return String(value || '').trim().toLowerCase() === 'true';
+}
+
+function resolveLevel() {
+  const debugMode = asBoolean(process.env.DEBUG_MODE);
+  const configured = String(process.env.I18NTK_LOG_LEVEL || '').trim().toLowerCase();
+  if (configured && Object.prototype.hasOwnProperty.call(LEVELS, configured)) {
+    return configured;
+  }
+
+  if (debugMode) {
+    return 'debug';
+  }
+
+  // Silent-by-default in production-like builds.
+  if (process.env.NODE_ENV === 'production' || asBoolean(process.env.CI)) {
+    return 'error';
+  }
+
+  return 'warn';
+}
+
+function shouldLog(level) {
+  const active = resolveLevel();
+  return LEVELS[level] <= LEVELS[active];
+}
+
+function normalizePrefix(prefix, fallback) {
+  const value = String(prefix || fallback || '[INFO]').trim();
+  if (/^\[[^\]]+\]$/.test(value)) {
+    return value;
+  }
+  return `[${value.replace(/^[\[]|[\]]$/g, '').toUpperCase()}]`;
+}
+
+function write(level, message, options = {}) {
+  if (!shouldLog(level)) return;
+
+  const jsonMode = asBoolean(process.env.JSON_LOG);
+  const prefix = normalizePrefix(options.prefix, `[${level.toUpperCase()}]`);
+  const details = options.details && typeof options.details === 'object' ? options.details : undefined;
+  const text = String(message || '').trim();
+
+  if (jsonMode) {
+    const payload = {
+      timestamp: new Date().toISOString(),
+      level,
+      prefix,
+      message: text,
+      ...(details ? { details } : {})
+    };
+    const line = JSON.stringify(payload);
+    if (level === 'error' || level === 'warn') {
+      process.stderr.write(`${line}\n`);
+    } else {
+      process.stdout.write(`${line}\n`);
+    }
+    return;
+  }
+
+  const line = `${prefix}  ${text}`;
+  if (level === 'error') {
+    process.stderr.write(`${colors.red(line)}\n`);
+    return;
+  }
+  if (level === 'warn') {
+    process.stderr.write(`${colors.yellow(line)}\n`);
+    return;
+  }
+  if (level === 'debug') {
+    process.stdout.write(`${colors.gray(line)}\n`);
+    return;
+  }
+
+  process.stdout.write(`${line}\n`);
+}
+
+function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return 'instant';
+  if (ms < 50) return 'instant';
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.round((ms % 60000) / 1000);
+  return `${minutes}m${seconds}s`;
+}
+
+function recordFirstError(key, context) {
+  if (!key || FIRST_ERROR_CONTEXT.has(key)) {
+    return;
+  }
+
+  FIRST_ERROR_CONTEXT.set(key, {
+    timestamp: new Date().toISOString(),
+    ...context
+  });
+}
+
+function getFirstErrorContext(key) {
+  return FIRST_ERROR_CONTEXT.get(key) || null;
+}
+
+function flushErrorContexts() {
+  const entries = Array.from(FIRST_ERROR_CONTEXT.entries()).map(([key, value]) => ({ key, ...value }));
+  FIRST_ERROR_CONTEXT.clear();
+  return entries;
+}
+
+function emitErrorContextSummary({ force = false } = {}) {
+  const contexts = Array.from(FIRST_ERROR_CONTEXT.entries());
+  if (!contexts.length) return;
+  if (!force && !asBoolean(process.env.DEBUG_MODE)) return;
+
+  for (const [key, context] of contexts) {
+    write('debug', `First error context (${key})`, { prefix: '[ERROR]', details: context });
+  }
+}
+
+function logMissingTranslationKey(key, fallback = 'Configuration error') {
+  write('warn', `Missing key: ${key} (fallback: '${fallback}')`, { prefix: '[I18N]' });
+}
+
+function createBuildProgressReporter(totalPages) {
+  const safeTotal = Math.max(1, Number(totalPages) || 1);
+  let lastBucket = 0;
+
+  return {
+    update(completedPages) {
+      const completed = Math.max(0, Math.min(safeTotal, Number(completedPages) || 0));
+      const percent = Math.floor((completed / safeTotal) * 100);
+      const bucket = Math.floor(percent / 10) * 10;
+      if (bucket <= lastBucket || bucket === 0) return;
+      lastBucket = bucket;
+
+      const pct = `${String(bucket).padStart(3, ' ')}%`;
+      write('info', `${pct} (${completed}/${safeTotal} pages)`, { prefix: '[BUILD]' });
+    }
+  };
+}
+
+function buildSuccessSummary({ durationMs, pages, warnings = 0 }) {
+  const duration = formatDuration(durationMs);
+  write('info', `Build completed in ${duration} (${pages} pages, ${warnings} warnings)`, { prefix: '[SUCCESS]' });
+}
+
+function createWorkerPoolMonitor(activeWorkers = 0) {
+  const startedAt = Date.now();
+  let tasks = 0;
+  let totalTaskDurationMs = 0;
+  let workers = Math.max(0, Number(activeWorkers) || 0);
+
+  return {
+    setActive(count) {
+      workers = Math.max(0, Number(count) || 0);
+    },
+    recordTask(durationMs) {
+      tasks += 1;
+      totalTaskDurationMs += Math.max(0, Number(durationMs) || 0);
+    },
+    report() {
+      const avg = tasks > 0 ? (totalTaskDurationMs / tasks) / 1000 : 0;
+      write('info', `${workers} active (avg ${avg.toFixed(1)}s/task)`, { prefix: '[WORKERS]' });
+      return {
+        workers,
+        tasks,
+        avgSecondsPerTask: Number(avg.toFixed(2)),
+        elapsed: formatDuration(Date.now() - startedAt)
+      };
+    }
+  };
+}
+
+const logger = {
+  log(message, color = null) {
+    const output = typeof color === 'function' ? color(String(message)) : String(message);
+    write('info', output, { prefix: '[INFO]' });
+  },
+  info(message, details) {
+    write('info', String(message), { prefix: '[INFO]', details });
+  },
+  warn(message, details) {
+    write('warn', String(message), { prefix: '[WARN]', details });
+  },
+  error(message, details) {
+    write('error', String(message), { prefix: '[ERROR]', details });
+  },
+  debug(message, details) {
+    write('debug', String(message), { prefix: '[DEBUG]', details });
+  },
+  success(message, details) {
+    write('info', String(message), { prefix: '[SUCCESS]', details });
+  },
+  security(level, message, details) {
+    write(level, String(message), { prefix: '[SECURITY]', details });
+  },
+  build(message, details) {
+    write('info', String(message), { prefix: '[BUILD]', details });
+  },
+  isDebugMode() {
+    return asBoolean(process.env.DEBUG_MODE) || resolveLevel() === 'debug';
+  },
+  shouldLog,
+  formatDuration,
+  recordFirstError,
+  getFirstErrorContext,
+  flushErrorContexts,
+  emitErrorContextSummary,
+  buildSuccessSummary,
+  logMissingTranslationKey,
+  createBuildProgressReporter,
+  createWorkerPoolMonitor,
+  // Keep compatibility for callers that rely on known prefixes.
+  KNOWN_PREFIXES: DEFAULT_INTERNAL_PREFIXES
+};
+
+module.exports = {
+  colors,
+  logger,
+  formatDuration,
+  createBuildProgressReporter,
+  createWorkerPoolMonitor,
+  recordFirstError,
+  getFirstErrorContext,
+  flushErrorContexts,
+  emitErrorContextSummary
+};

package/utils/npm-version-warning.js

@@ -1,147 +1,18 @@
-const https = require('https');
-const { compareVersions } = require('./version-utils');
+'use strict';
 
-const DEFAULT_TIMEOUT_MS = 1800;
-const NPM_REGISTRY_BASE = 'https://registry.npmjs.org';
+/**
+ * Update checks were intentionally removed to avoid outbound network access
+ * during CLI startup and to reduce scanner noise in restricted environments.
+ *
+ * We keep the same exported API for backwards compatibility.
+ */
 
-function isSemverLike(version) {
-  return typeof version === 'string' && /^\d+\.\d+\.\d+([-.][0-9A-Za-z.-]+)?$/.test(version.trim());
+async function checkNpmOutdated() {
+  return null;
 }
 
-function fetchPackageMetadata(packageName, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const safePackageName = encodeURIComponent(packageName);
-  const requestUrl = `${NPM_REGISTRY_BASE}/${safePackageName}`;
-
-  return new Promise((resolve) => {
-    let settled = false;
-
-    const finish = (value) => {
-      if (!settled) {
-        settled = true;
-        resolve(value);
-      }
-    };
-
-    const req = https.get(
-      requestUrl,
-      {
-        timeout: timeoutMs,
-        headers: {
-          Accept: 'application/json',
-          'User-Agent': 'i18ntk-version-check'
-        }
-      },
-      (res) => {
-        if (res.statusCode !== 200) {
-          res.resume();
-          finish(null);
-          return;
-        }
-
-        let raw = '';
-        res.on('data', (chunk) => {
-          raw += chunk;
-        });
-        res.on('end', () => {
-          try {
-            finish(JSON.parse(raw));
-          } catch {
-            finish(null);
-          }
-        });
-      }
-    );
-
-    req.on('timeout', () => {
-      req.destroy();
-      finish(null);
-    });
-    req.on('error', () => finish(null));
-  });
-}
-
-function getOutdatedStatus(currentVersion, metadata) {
-  if (!isSemverLike(currentVersion) || !metadata || !metadata.versions) {
-    return null;
-  }
-
-  const distTags = metadata['dist-tags'] || {};
-  const taggedLatest = distTags.latest;
-  const allPublishedVersions = Object.keys(metadata.versions).filter(isSemverLike);
-
-  if (allPublishedVersions.length === 0) {
-    return null;
-  }
-
-  const latestVersion = isSemverLike(taggedLatest)
-    ? taggedLatest
-    : allPublishedVersions.sort(compareVersions).at(-1);
-
-  if (!latestVersion || !isSemverLike(latestVersion)) {
-    return null;
-  }
-
-  const currentMeta = metadata.versions[currentVersion] || null;
-  const isCurrentDeprecated = Boolean(currentMeta && currentMeta.deprecated);
-  const isOutdated = compareVersions(currentVersion, latestVersion) < 0;
-
-  const newerStableVersions = allPublishedVersions.filter((version) => (
-    compareVersions(version, currentVersion) > 0 &&
-    compareVersions(version, latestVersion) <= 0
-  ));
-
-  return {
-    latestVersion,
-    isOutdated,
-    isCurrentDeprecated,
-    newerStableCount: newerStableVersions.length
-  };
-}
-
-async function checkNpmOutdated({ packageName, currentVersion, timeoutMs = DEFAULT_TIMEOUT_MS }) {
-  const metadata = await fetchPackageMetadata(packageName, timeoutMs);
-  return getOutdatedStatus(currentVersion, metadata);
-}
-
-async function printUpgradeWarningIfOutdated({
-  packageName,
-  currentVersion,
-  timeoutMs = DEFAULT_TIMEOUT_MS
-}) {
-  const enabled = String(process.env.I18NTK_ENABLE_UPDATE_CHECK || '').toLowerCase();
-  if (!(enabled === '1' || enabled === 'true' || enabled === 'yes')) {
-    return;
-  }
-
-  if (process.env.I18NTK_DISABLE_UPDATE_CHECK === 'true') {
-    return;
-  }
-
-  const status = await checkNpmOutdated({ packageName, currentVersion, timeoutMs });
-  if (!status) {
-    return;
-  }
-
-  if (status.isCurrentDeprecated) {
-    console.warn(
-      `\n⚠️  Installed ${packageName}@${currentVersion} is deprecated on npm. ` +
-      `Upgrade to ${packageName}@${status.latestVersion}:\n` +
-      `   npm install -g ${packageName}@latest`
-    );
-    return;
-  }
-
-  if (status.isOutdated) {
-    const suffix = status.newerStableCount === 1 ? '' : 's';
-    console.warn(
-      `\n⚠️  Update available for ${packageName}: ${currentVersion} -> ${status.latestVersion} ` +
-      `(${status.newerStableCount} newer release${suffix}).\n` +
-      `   Run: npm install -g ${packageName}@latest`
-    );
-  }
+async function printUpgradeWarningIfOutdated() {
+  return;
 }
 
-module.exports = {
-  checkNpmOutdated,
-  printUpgradeWarningIfOutdated
-};
+module.exports = { checkNpmOutdated, printUpgradeWarningIfOutdated };