i18ntk 1.10.1 → 2.0.2

package/utils/init-helper.js

@@ -1,81 +1,121 @@
-const fs = require('fs');
-const path = require('path');
-const configManager = require('./config-helper');
-const { ensureDirectory } = require('./config-helper');
+const fs = require('fs');
+const path = require('path');
+const configManager = require('./config-manager');
+const SecurityUtils = require('./security');
+
+function ensureDirectory(dirPath) {
+  if (!dirPath || typeof dirPath !== 'string') return;
+  if (!SecurityUtils.safeExistsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function readJsonSafe(filePath) {
+  try {
+    if (!SecurityUtils.safeExistsSync(filePath)) return null;
+    const raw = SecurityUtils.safeReadFileSync(filePath, path.dirname(filePath), 'utf8');
+    if (!raw) return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function hasSourceLanguageFiles(sourceDir, sourceLanguage) {
+  const baseSourceDir = path.resolve(sourceDir);
+  const modularLanguageDir = path.join(baseSourceDir, sourceLanguage);
+  const singleLanguageFile = path.join(baseSourceDir, `${sourceLanguage}.json`);
+
+  if (SecurityUtils.safeExistsSync(modularLanguageDir)) {
+    try {
+      if (fs.statSync(modularLanguageDir).isDirectory()) {
+        return fs.readdirSync(modularLanguageDir).some(file => file.endsWith('.json'));
+      }
+    } catch {
+      // Continue with single-file fallback.
+    }
+  }
+
+  return SecurityUtils.safeExistsSync(singleLanguageFile);
+}
 
 /**
  * Check if the project is properly initialized
  * @param {Object} options - Options for initialization check
  * @returns {Promise<Object>} Object containing initialization status and config
  */
-async function checkInitialized(options = {}) {
-  const settings = configManager.loadSettings ? configManager.loadSettings() : (configManager.getConfig ? configManager.getConfig() : {});
-  const currentVersion = require('../package.json').version;
-  const configDir = settings.configDir || './settings';
-  
-  // Ensure config directory exists
-  ensureDirectory(configDir);
-  
+async function checkInitialized(options = {}) {
+  const settings = configManager.getConfig ? configManager.getConfig() : {};
+  const currentVersion = require('../package.json').version;
+  const projectConfigPath = configManager.CONFIG_PATH || path.join(process.cwd(), '.i18ntk-config');
+  const configDir = path.dirname(projectConfigPath);
+  
+  // Ensure config directory exists
+  ensureDirectory(configDir);
+  
   const defaultConfig = {
     sourceDir: settings.sourceDir || './locales',
     sourceLanguage: settings.sourceLanguage || 'en',
     projectRoot: path.resolve('.'),
     framework: settings.framework || { detected: false, prompt: 'always' },
-    configDir: configDir
-  };
-
-  // Check initialization status file with consistent path resolution
-  const initFilePath = path.resolve(configDir, 'initialization.json');
-  
-  // If initialization file exists and is valid, return early
-  if (fs.existsSync(initFilePath)) {
-    try {
-      const initStatus = JSON.parse(fs.readFileSync(initFilePath, 'utf8'));
-      const isInitialized = initStatus.initialized && 
-                          initStatus.version && 
-                          initStatus.version.split('.')[0] === currentVersion.split('.')[0];
-      
-      if (isInitialized) {
-        // Merge with default config but don't override existing settings
-        return {
-          initialized: true,
-          config: { 
-            ...defaultConfig, 
-            ...initStatus,
-            // Don't override framework settings if they exist
-            framework: initStatus.framework || defaultConfig.framework
-          }
-        };
-      }
-    } catch (e) {
-      console.warn('Warning: Invalid initialization file, will reinitialize...', e.message);
-    }
-  }
-
-  // Check if source language files exist
-  const langDir = path.resolve(defaultConfig.sourceDir, defaultConfig.sourceLanguage);
-  const hasLanguageFiles = fs.existsSync(langDir) &&
-    fs.readdirSync(langDir).some(f => f.endsWith('.json'));
-
-  // If language files exist but no init file, create one
-  if (hasLanguageFiles) {
-    const initData = {
-      initialized: true,
-      version: currentVersion,
-      timestamp: new Date().toISOString(),
-      sourceDir: defaultConfig.sourceDir,
-      sourceLanguage: defaultConfig.sourceLanguage,
-      detectedLanguage: defaultConfig.detectedLanguage,
-      detectedFramework: defaultConfig.detectedFramework,
-      lastUpdated: new Date().toISOString()
-    };
-    
-    ensureDirectory(path.dirname(initFilePath));
-    fs.writeFileSync(initFilePath, JSON.stringify(initData, null, 2));
-    
-    return {
-      initialized: true,
-      config: { ...defaultConfig, ...initData }
+    configDir: configDir
+  };
+
+  // Primary source of truth in v2: project-level .i18ntk-config
+  const projectConfig = readJsonSafe(projectConfigPath);
+  if (projectConfig?.setup?.completed === true) {
+    return {
+      initialized: true,
+      config: {
+        ...defaultConfig,
+        ...projectConfig,
+        framework: projectConfig.framework || defaultConfig.framework
+      }
+    };
+  }
+
+  // Backward compatibility: legacy initialization marker file.
+  const initFilePath = path.join(configDir, 'initialization.json');
+  const initStatus = readJsonSafe(initFilePath);
+  const isLegacyInitialized = Boolean(initStatus?.initialized) && (
+    !initStatus.version ||
+    initStatus.version.split('.')[0] === currentVersion.split('.')[0]
+  );
+  if (isLegacyInitialized) {
+    return {
+      initialized: true,
+      config: {
+        ...defaultConfig,
+        ...initStatus,
+        framework: initStatus.framework || defaultConfig.framework
+      }
+    };
+  }
+
+  // Final fallback: detect existing source language files and mark initialized.
+  const sourceDir = options.sourceDir || defaultConfig.sourceDir;
+  const sourceLanguage = options.sourceLanguage || defaultConfig.sourceLanguage;
+  const hasLanguageFiles = hasSourceLanguageFiles(sourceDir, sourceLanguage);
+
+  // If language files exist but no init file, create one
+  if (hasLanguageFiles) {
+    const initData = {
+      initialized: true,
+      version: currentVersion,
+      timestamp: new Date().toISOString(),
+      sourceDir,
+      sourceLanguage,
+      detectedLanguage: defaultConfig.detectedLanguage,
+      detectedFramework: defaultConfig.detectedFramework,
+      lastUpdated: new Date().toISOString()
+    };
+    
+    ensureDirectory(path.dirname(initFilePath));
+    SecurityUtils.safeWriteFileSync(initFilePath, JSON.stringify(initData, null, 2), path.dirname(initFilePath), 'utf8');
+    
+    return {
+      initialized: true,
+      config: { ...defaultConfig, ...initData }
     };
   }
 
@@ -90,33 +130,51 @@ async function checkInitialized(options = {}) {
  * @param {Object} config - Configuration to save
  * @returns {Promise<void>}
  */
-async function markAsInitialized(config) {
-  const settings = configManager.loadSettings ? configManager.loadSettings() : (configManager.getConfig ? configManager.getConfig() : {});
-  const configDir = settings.configDir || './settings';
-  const initFilePath = path.resolve(configDir, 'initialization.json');
-  const currentVersion = require('../package.json').version;
-  
-  const initData = {
-    initialized: true,
-    version: currentVersion,
-    timestamp: new Date().toISOString(),
-    sourceDir: config.sourceDir,
-    sourceLanguage: config.sourceLanguage,
-    detectedLanguage: config.detectedLanguage,
-    detectedFramework: config.detectedFramework,
-    lastUpdated: new Date().toISOString()
-  };
-  
-  ensureDirectory(path.dirname(initFilePath));
-  fs.writeFileSync(initFilePath, JSON.stringify(initData, null, 2));
-  
-  // Update the settings object if it has a save method
-  if (configManager.saveSettings) {
-    await configManager.saveSettings({ ...settings, ...initData });
-  } else if (configManager.saveConfig) {
-    await configManager.saveConfig({ ...settings, ...initData });
-  }
-}
+async function markAsInitialized(config) {
+  const settings = configManager.getConfig ? configManager.getConfig() : {};
+  const projectConfigPath = configManager.CONFIG_PATH || path.join(process.cwd(), '.i18ntk-config');
+  const configDir = path.dirname(projectConfigPath);
+  const initFilePath = path.join(configDir, 'initialization.json');
+  const currentVersion = require('../package.json').version;
+  const now = new Date().toISOString();
+  const sourceDir = config?.sourceDir || settings.sourceDir || './locales';
+  const sourceLanguage = config?.sourceLanguage || settings.sourceLanguage || 'en';
+  
+  const initData = {
+    initialized: true,
+    version: currentVersion,
+    timestamp: now,
+    sourceDir,
+    sourceLanguage,
+    detectedLanguage: config?.detectedLanguage || settings.detectedLanguage,
+    detectedFramework: config?.detectedFramework || settings.detectedFramework,
+    lastUpdated: now
+  };
+  
+  ensureDirectory(path.dirname(initFilePath));
+  SecurityUtils.safeWriteFileSync(initFilePath, JSON.stringify(initData, null, 2), path.dirname(initFilePath), 'utf8');
+
+  const mergedConfig = {
+    ...settings,
+    ...(config || {}),
+    sourceDir,
+    sourceLanguage,
+    version: currentVersion,
+    setup: {
+      ...(settings.setup || {}),
+      completed: true,
+      completedAt: now,
+      version: currentVersion,
+      setupId: settings.setup?.setupId || `setup_${Date.now()}`
+    }
+  };
+  
+  if (configManager.saveConfig) {
+    await configManager.saveConfig(mergedConfig);
+  } else {
+    SecurityUtils.safeWriteFileSync(projectConfigPath, JSON.stringify(mergedConfig, null, 2), path.dirname(projectConfigPath), 'utf8');
+  }
+}
 
 module.exports = {
   checkInitialized,

package/utils/json-output.js

@@ -1,99 +1,99 @@
-/**
- * JSON Output Utility for i18ntk commands
- * Provides consistent machine-readable output format for CI/CD integration
- */
-
-class JsonOutput {
-  constructor(command) {
-    this.command = command;
-    this.version = this.getPackageVersion();
-    this.startTime = Date.now();
-    this.data = {
-      command: this.command,
-      version: this.version,
-      status: 'ok',
-      stats: {},
-      issues: [],
-      metadata: {
-        timestamp: new Date().toISOString(),
-        duration: 0
-      }
-    };
-  }
-
-  getPackageVersion() {
-    try {
-      const packageJson = require('../package.json');
-      return packageJson.version;
-    } catch (error) {
-      return '1.8.3';
-    }
-  }
-
-  /**
-   * Set the overall status
-   * @param {'ok'|'warn'|'error'} status 
-   */
-  setStatus(status) {
-    this.data.status = status;
-  }
-
-  /**
-   * Add statistics to the output
-   * @param {Object} stats 
-   */
-  setStats(stats) {
-    this.data.stats = { ...this.data.stats, ...stats };
-  }
-
-  /**
-   * Add an issue to the output
-   * @param {Object} issue 
-   */
-  addIssue(issue) {
-    this.data.issues.push({
-      file: issue.file || '',
-      key: issue.key || '',
-      type: issue.type || 'unknown',
-      message: issue.message || '',
-      severity: issue.severity || 'info'
-    });
-  }
-
-  /**
-   * Add metadata information
-   * @param {Object} metadata 
-   */
-  addMetadata(metadata) {
-    this.data.metadata = { ...this.data.metadata, ...metadata };
-  }
-
-  /**
-   * Finalize and output the JSON
-   */
-  output() {
-    this.data.metadata.duration = Date.now() - this.startTime;
-    
-    if (process.env.NODE_ENV !== 'test') {
-      console.log(JSON.stringify(this.data, null, 2));
-    }
-    
-    return this.data;
-  }
-
-  /**
-   * Output error in JSON format
-   * @param {Error} error 
-   */
-  outputError(error) {
-    this.setStatus('error');
-    this.addIssue({
-      type: 'error',
-      message: error.message,
-      severity: 'error'
-    });
-    this.output();
-  }
-}
-
+/**
+ * JSON Output Utility for i18ntk commands
+ * Provides consistent machine-readable output format for CI/CD integration
+ */
+
+class JsonOutput {
+  constructor(command) {
+    this.command = command;
+    this.version = this.getPackageVersion();
+    this.startTime = Date.now();
+    this.data = {
+      command: this.command,
+      version: this.version,
+      status: 'ok',
+      stats: {},
+      issues: [],
+      metadata: {
+        timestamp: new Date().toISOString(),
+        duration: 0
+      }
+    };
+  }
+
+  getPackageVersion() {
+    try {
+      const packageJson = require('../package.json');
+      return packageJson.version;
+    } catch (error) {
+      return '1.8.3';
+    }
+  }
+
+  /**
+   * Set the overall status
+   * @param {'ok'|'warn'|'error'} status 
+   */
+  setStatus(status) {
+    this.data.status = status;
+  }
+
+  /**
+   * Add statistics to the output
+   * @param {Object} stats 
+   */
+  setStats(stats) {
+    this.data.stats = { ...this.data.stats, ...stats };
+  }
+
+  /**
+   * Add an issue to the output
+   * @param {Object} issue 
+   */
+  addIssue(issue) {
+    this.data.issues.push({
+      file: issue.file || '',
+      key: issue.key || '',
+      type: issue.type || 'unknown',
+      message: issue.message || '',
+      severity: issue.severity || 'info'
+    });
+  }
+
+  /**
+   * Add metadata information
+   * @param {Object} metadata 
+   */
+  addMetadata(metadata) {
+    this.data.metadata = { ...this.data.metadata, ...metadata };
+  }
+
+  /**
+   * Finalize and output the JSON
+   */
+  output() {
+    this.data.metadata.duration = Date.now() - this.startTime;
+    
+    if (process.env.NODE_ENV !== 'test') {
+      console.log(JSON.stringify(this.data, null, 2));
+    }
+    
+    return this.data;
+  }
+
+  /**
+   * Output error in JSON format
+   * @param {Error} error 
+   */
+  outputError(error) {
+    this.setStatus('error');
+    this.addIssue({
+      type: 'error',
+      message: error.message,
+      severity: 'error'
+    });
+    this.output();
+  }
+}
+
 module.exports = JsonOutput;

package/utils/logger.js

@@ -1,4 +1,5 @@
 const colors = require('./colors-new');
+const { envManager } = require('./env-manager');
 
 // Enhanced logger with TTY detection and proper stream handling
 const logger = {
@@ -44,9 +45,12 @@ const logger = {
     logger.log(output, colors.blue);
   },
   
-  // Debug logging (only when DEBUG env var is set)
+  // Debug logging (only when DEBUG env var is set or log level is debug)
   debug: (message) => {
-    if (process.env.DEBUG) {
+    const logLevel = envManager.get('I18NTK_LOG_LEVEL');
+    const debugEnabled = process.env.DEBUG || logLevel === 'debug';
+    
+    if (debugEnabled) {
       const output = `[DEBUG] ${message}`;
       if (process.stderr.isTTY) {
         process.stderr.write(colors.gray(output) + '\n');

package/utils/mini-commander.js

@@ -0,0 +1,179 @@
+/**
+ * Minimal zero-dependency subset of commander used by i18ntk language CLIs.
+ */
+
+function toCamelCase(input) {
+  return String(input || '').replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+function parseOptionDefinition(flags, defaultValue) {
+  const longMatch = flags.match(/--([a-zA-Z0-9-]+)/);
+  const shortMatch = flags.match(/(^|\s)-([a-zA-Z])(\s|,|$)/);
+  const hasValue = /<[^>]+>/.test(flags);
+  const longName = longMatch ? longMatch[1] : null;
+  const shortName = shortMatch ? shortMatch[2] : null;
+  const name = toCamelCase(longName || shortName || '');
+
+  return {
+    flags,
+    hasValue,
+    defaultValue,
+    longFlag: longName ? `--${longName}` : null,
+    shortFlag: shortName ? `-${shortName}` : null,
+    name
+  };
+}
+
+function parseOptions(args, optionDefs) {
+  const options = {};
+
+  for (const def of optionDefs) {
+    if (def.defaultValue !== undefined) {
+      options[def.name] = def.defaultValue;
+    } else if (!def.hasValue) {
+      options[def.name] = false;
+    }
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg || !arg.startsWith('-')) {
+      continue;
+    }
+
+    let matchedDef = null;
+    let inlineValue;
+
+    if (arg.startsWith('--')) {
+      const [flag, value] = arg.split('=', 2);
+      matchedDef = optionDefs.find(def => def.longFlag === flag);
+      inlineValue = value;
+    } else {
+      matchedDef = optionDefs.find(def => def.shortFlag === arg);
+    }
+
+    if (!matchedDef) {
+      continue;
+    }
+
+    if (!matchedDef.hasValue) {
+      options[matchedDef.name] = true;
+      continue;
+    }
+
+    let value = inlineValue;
+    if (value === undefined) {
+      const next = args[i + 1];
+      if (next !== undefined && !String(next).startsWith('-')) {
+        value = next;
+        i++;
+      }
+    }
+
+    options[matchedDef.name] = value !== undefined ? value : '';
+  }
+
+  return options;
+}
+
+class MiniCommand {
+  constructor(name) {
+    this._name = name;
+    this._description = '';
+    this._options = [];
+    this._action = null;
+  }
+
+  description(text) {
+    this._description = text;
+    return this;
+  }
+
+  option(flags, _description, defaultValue) {
+    this._options.push(parseOptionDefinition(flags, defaultValue));
+    return this;
+  }
+
+  action(handler) {
+    this._action = handler;
+    return this;
+  }
+
+  execute(args) {
+    const parsed = parseOptions(args, this._options);
+    if (typeof this._action === 'function') {
+      const result = this._action(parsed);
+      if (result && typeof result.then === 'function') {
+        result.catch(error => {
+          console.error(error && error.message ? error.message : String(error));
+          process.exit(1);
+        });
+      }
+    }
+  }
+}
+
+class MiniProgram {
+  constructor() {
+    this._name = '';
+    this._description = '';
+    this._version = '';
+    this._options = [];
+    this._commands = [];
+    this._opts = {};
+  }
+
+  name(value) {
+    this._name = value;
+    return this;
+  }
+
+  description(value) {
+    this._description = value;
+    return this;
+  }
+
+  version(value) {
+    this._version = value;
+    return this;
+  }
+
+  option(flags, _description, defaultValue) {
+    this._options.push(parseOptionDefinition(flags, defaultValue));
+    return this;
+  }
+
+  command(name) {
+    const command = new MiniCommand(name);
+    this._commands.push(command);
+    return command;
+  }
+
+  opts() {
+    return { ...this._opts };
+  }
+
+  parse(argv = process.argv) {
+    const args = argv.slice(2);
+
+    if (this._commands.length > 0 && args.length > 0 && !args[0].startsWith('-')) {
+      const command = this._commands.find(item => item._name === args[0]);
+      if (command) {
+        command.execute(args.slice(1));
+        return this;
+      }
+    }
+
+    this._opts = parseOptions(args, this._options);
+    return this;
+  }
+}
+
+function createProgram() {
+  return new MiniProgram();
+}
+
+module.exports = {
+  createProgram,
+  program: createProgram()
+};