i18ntk 4.2.2 → 4.3.1

package/main/i18ntk-py.js

@@ -0,0 +1,379 @@
+#!/usr/bin/env node
+
+/**
+ * i18ntk Python Command
+ * Specialized command for Python i18n management
+ *
+ * Usage: i18ntk-py [options]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SecurityUtils = require('../utils/security');
+const { getConfig, saveConfig } = require('../utils/config-helper');
+const I18nHelper = require('../utils/i18n-helper');
+const SetupEnforcer = require('../utils/setup-enforcer');
+const { program } = require('../utils/mini-commander');
+
+(async () => {
+  try {
+    await SetupEnforcer.checkSetupCompleteAsync();
+  } catch (error) {
+    console.error('Setup check failed:', error.message);
+    process.exit(1);
+  }
+})();
+
+class I18ntkPythonCommand {
+  constructor() {
+    this.config = null;
+    this.sourceDir = './locales';
+    this.pythonPatterns = [
+      /_(?:gettext)?\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
+      /gettext\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
+      /gettext_lazy\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
+      /ngettext\s*\(\s*["'`]([^"'`]+)["'`]\s*,/g,
+      /lazy_gettext\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
+      /ugettext\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g
+    ];
+  }
+
+  async init() {
+    console.log('🔧 Initializing i18ntk Python command...');
+
+    program
+      .name('i18ntk-py')
+      .description('i18ntk specialized for Python applications')
+      .version('1.10.1')
+      .option('-s, --source-dir <dir>', 'Source directory to scan', './')
+      .option('-l, --locales-dir <dir>', 'Locales directory', './locales')
+      .option('--framework <type>', 'Python framework type', 'auto')
+      .option('--dry-run', 'Show what would be done without making changes')
+      .option('--debug', 'Enable debug output')
+      .option('--extract-only', 'Only extract translations, don\'t analyze')
+      .option('--django', 'Force Django mode')
+      .option('--flask', 'Force Flask mode')
+      .option('--generic', 'Force generic Python mode')
+      .parse();
+
+    this.options = program.opts();
+    this.sourceDir = path.resolve(this.options.sourceDir);
+    this.localesDir = path.resolve(this.options.localesDir);
+
+    await this.validateSourceDir();
+    await this.loadConfig();
+  }
+
+  async validateSourceDir() {
+    if (!SecurityUtils.safeExistsSync(this.sourceDir, path.dirname(this.sourceDir))) {
+      console.error(`❌ Source directory not found: ${this.sourceDir}`);
+      process.exit(1);
+    }
+
+    const stats = fs.statSync(this.sourceDir);
+    if (!stats.isDirectory()) {
+      console.error(`❌ Source path is not a directory: ${this.sourceDir}`);
+      process.exit(1);
+    }
+  }
+
+  async loadConfig() {
+    try {
+      this.config = await getConfig();
+      this.config.python = this.config.python || {};
+    } catch (error) {
+      console.warn('⚠️  Could not load config, using defaults');
+      this.config = { python: {} };
+    }
+  }
+
+  async detectFramework() {
+    if (this.options.django) return 'django';
+    if (this.options.flask) return 'flask';
+    if (this.options.generic) return 'generic';
+
+    console.log('🔍 Detecting Python framework...');
+
+    // Check for Django
+    const djangoIndicators = [
+      'manage.py',
+      'settings.py',
+      'requirements.txt',
+      'django'
+    ];
+
+    // Check for Flask
+    const flaskIndicators = [
+      'app.py',
+      'requirements.txt',
+      'flask'
+    ];
+
+    let framework = 'generic';
+
+    try {
+      // Check requirements.txt
+      const requirementsPath = path.join(this.sourceDir, 'requirements.txt');
+      if (SecurityUtils.safeExistsSync(requirementsPath, this.sourceDir)) {
+        const requirements = SecurityUtils.safeReadFileSync(requirementsPath, this.sourceDir, 'utf8');
+        if (requirements.includes('Django')) framework = 'django';
+        else if (requirements.includes('Flask')) framework = 'flask';
+      }
+
+      // Check for Django files
+      for (const indicator of djangoIndicators) {
+        if (this.findFiles(indicator).length > 0) {
+          framework = 'django';
+          break;
+        }
+      }
+
+      // Check for Flask files
+      for (const indicator of flaskIndicators) {
+        if (this.findFiles(indicator).length > 0) {
+          framework = 'flask';
+          break;
+        }
+      }
+
+    } catch (error) {
+      if (this.options.debug) {
+        console.error('Debug: Framework detection error:', error.message);
+      }
+    }
+
+    console.log(`✅ Detected framework: ${framework}`);
+    return framework;
+  }
+
+  findFiles(pattern) {
+    const results = [];
+
+    function scanDir(dir) {
+      if (!SecurityUtils.safeExistsSync(dir, path.dirname(dir))) return;
+
+      const items = fs.readdirSync(dir);
+      for (const item of items) {
+        const fullPath = path.join(dir, item);
+        const stat = fs.statSync(fullPath);
+
+        if (stat.isDirectory() && !item.startsWith('.') && item !== 'node_modules') {
+          scanDir(fullPath);
+        } else if (item.includes(pattern) || fullPath.includes(pattern)) {
+          results.push(fullPath);
+        }
+      }
+    }
+
+    scanDir(this.sourceDir);
+    return results;
+  }
+
+  async extractTranslations() {
+    console.log('📦 Extracting Python translations...');
+
+    const pythonFiles = this.findFiles('.py');
+    const translations = new Set();
+
+    for (const file of pythonFiles) {
+      try {
+        const content = SecurityUtils.safeReadFileSync(file, path.dirname(file), 'utf8');
+
+        for (const pattern of this.pythonPatterns) {
+          let match;
+          while ((match = pattern.exec(content)) !== null) {
+            translations.add(match[1]);
+          }
+        }
+
+        // Reset regex state for next file
+        for (const pattern of this.pythonPatterns) {
+          pattern.lastIndex = 0;
+        }
+
+      } catch (error) {
+        if (this.options.debug) {
+          console.error(`Error reading ${file}:`, error.message);
+        }
+      }
+    }
+
+    console.log(`📊 Found ${translations.size} unique translation keys`);
+    return Array.from(translations);
+  }
+
+  async createLocaleStructure() {
+    if (!SecurityUtils.safeExistsSync(this.localesDir, path.dirname(this.localesDir))) {
+      if (this.options.dryRun) {
+        console.log(`📁 Would create directory: ${this.localesDir}`);
+        return;
+      }
+
+      fs.mkdirSync(this.localesDir, { recursive: true });
+      console.log(`📁 Created locales directory: ${this.localesDir}`);
+    }
+
+    const languages = ['en', 'es', 'fr', 'de', 'ja', 'ru', 'zh'];
+
+    for (const lang of languages) {
+      const langDir = path.join(this.localesDir, lang);
+      if (!SecurityUtils.safeExistsSync(langDir, this.localesDir)) {
+        if (this.options.dryRun) {
+          console.log(`📁 Would create directory: ${langDir}`);
+          continue;
+        }
+
+        fs.mkdirSync(langDir, { recursive: true });
+
+        // Create basic translation files
+        const commonFile = path.join(langDir, 'common.json');
+        const initialContent = {
+          "python": {
+            "welcome": `Welcome to Python (${lang})`,
+            "framework_detected": "Framework detected: {framework}",
+            "files_processed": "Processed {count} files"
+          }
+        };
+
+        SecurityUtils.safeWriteFileSync(commonFile, JSON.stringify(initialContent, null, 2), this.localesDir);
+      }
+    }
+  }
+
+  async analyzeFramework(framework) {
+    console.log(`🔍 Analyzing ${framework} project...`);
+
+    const analysis = {
+      framework,
+      files: {
+        total: 0,
+        python: 0,
+        templates: 0,
+        config: 0
+      },
+      patterns: {
+        gettext: 0,
+        gettext_lazy: 0,
+        ngettext: 0,
+        django: 0,
+        flask: 0
+      },
+      recommendations: []
+    };
+
+    // Count Python files
+    const pythonFiles = this.findFiles('.py');
+    analysis.files.python = pythonFiles.length;
+    analysis.files.total += pythonFiles.length;
+
+    // Count template files
+    const templateExtensions = ['.html', '.jinja', '.j2'];
+    let templateFiles = [];
+    for (const ext of templateExtensions) {
+      templateFiles = templateFiles.concat(this.findFiles(ext));
+    }
+    analysis.files.templates = templateFiles.length;
+    analysis.files.total += templateFiles.length;
+
+    // Analyze patterns
+    for (const file of pythonFiles) {
+      try {
+        const content = SecurityUtils.safeReadFileSync(file, path.dirname(file), 'utf8');
+
+        if (content.includes('gettext(')) analysis.patterns.gettext++;
+        if (content.includes('gettext_lazy(')) analysis.patterns.gettext_lazy++;
+        if (content.includes('ngettext(')) analysis.patterns.ngettext++;
+        if (content.includes('django')) analysis.patterns.django++;
+        if (content.includes('flask')) analysis.patterns.flask++;
+
+      } catch (error) {
+        // Skip unreadable files
+      }
+    }
+
+    // Generate recommendations
+    if (framework === 'django' && analysis.patterns.gettext === 0) {
+      analysis.recommendations.push('Consider adding Django gettext for i18n support');
+    }
+
+    if (framework === 'flask' && analysis.patterns.gettext === 0) {
+      analysis.recommendations.push('Consider adding Flask-Babel for i18n support');
+    }
+
+    return analysis;
+  }
+
+  async generateReport(analysis, translations) {
+    const report = {
+      timestamp: new Date().toISOString(),
+      framework: analysis.framework,
+      summary: {
+        totalFiles: analysis.files.total,
+        pythonFiles: analysis.files.python,
+        templateFiles: analysis.files.templates,
+        translationKeys: translations.length
+      },
+      patterns: analysis.patterns,
+      recommendations: analysis.recommendations,
+      files: {
+        python: this.findFiles('.py'),
+        templates: this.findFiles('.html').concat(this.findFiles('.jinja')).concat(this.findFiles('.j2'))
+      },
+      translations: translations.sort()
+    };
+
+    const reportPath = path.join(this.sourceDir, 'i18ntk-py-report.json');
+
+    if (this.options.dryRun) {
+      console.log(`📊 Would create report: ${reportPath}`);
+      console.log('📋 Report contents:', JSON.stringify(report, null, 2));
+    } else {
+      SecurityUtils.safeWriteFileSync(reportPath, JSON.stringify(report, null, 2), this.sourceDir);
+      console.log(`📊 Report saved: ${reportPath}`);
+    }
+
+    return report;
+  }
+
+  async run() {
+    try {
+      console.log('🚀 i18ntk Python Command v1.10.1');
+      console.log('='.repeat(50));
+
+      await this.init();
+
+      const framework = await this.detectFramework();
+      const translations = await this.extractTranslations();
+
+      if (!this.options.extractOnly) {
+        await this.createLocaleStructure();
+        const analysis = await this.analyzeFramework(framework);
+        const report = await this.generateReport(analysis, translations);
+
+        console.log('\n✅ Analysis complete!');
+        console.log(`📊 Framework: ${framework}`);
+        console.log(`📄 Python files: ${analysis.files.python}`);
+        console.log(`🎯 Translation keys: ${translations.length}`);
+        console.log(`📋 Report: ${this.options.dryRun ? 'Not saved (dry-run)' : 'Saved to i18ntk-py-report.json'}`);
+      } else {
+        console.log(`📦 Extracted ${translations.length} translation keys`);
+      }
+
+    } catch (error) {
+      console.error('❌ Error:', error.message);
+      if (this.options.debug) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  const cmd = new I18ntkPythonCommand();
+  cmd.run();
+}
+
+module.exports = I18ntkPythonCommand;

package/main/i18ntk-translate.js

@@ -344,7 +344,7 @@ function normalizeLanguageCode(language) {
 
 function parseLanguagePrefix(value) {
   if (typeof value !== 'string') return null;
-  const match = value.match(/^\s*\[([A-Z]{2,3}(?:[-_][A-Z0-9]{2,4})?)\]\s*(.+)$/);
+  const match = value.match(/^\s*\[([A-Z]{2,3}(?:[-_][A-Z0-9]{2,4})?)\]\s*(.+)$/i);
   if (!match) return null;
   return {
     raw: match[1],
@@ -368,6 +368,28 @@ function isLanguagePrefixedEnglish(value, args = {}) {
   return hasLatinWordContent(prefix.text, 1) || isLikelyEnglish(prefix.text, args);
 }
 
+function isSafeUnchangedSourceCopy(value, args = {}) {
+  const text = String(value ?? '').trim();
+  if (!text) return false;
+
+  const normalized = text.toLowerCase();
+  const allowedTerms = new Set(['api']);
+  if (Array.isArray(args.allowedEnglishTerms)) {
+    args.allowedEnglishTerms
+      .filter(term => typeof term === 'string' && term.trim())
+      .forEach(term => allowedTerms.add(term.trim().toLowerCase()));
+  }
+  if (allowedTerms.has(normalized)) return true;
+
+  const tokens = text.match(/[A-Za-z0-9]+/g) || [];
+  if (tokens.length === 0) return true;
+
+  return tokens.every((token) => {
+    if (!/[A-Za-z]/.test(token)) return true;
+    return token.length <= 8 && /^[A-Z0-9]{2,}$/.test(token);
+  });
+}
+
 function isBrokenTranslationValue(value) {
   if (typeof value !== 'string') return false;
   const text = value.trim();
@@ -399,7 +421,9 @@ function shouldTranslateTargetValue(sourceValue, targetValue, args) {
   if (isUntranslatedMarker(targetValue)) return true;
   if (isBrokenTranslationValue(targetValue)) return true;
   if (isLanguagePrefixedEnglish(targetValue, args)) return true;
-  if (targetValue.trim() === String(sourceValue ?? '').trim()) return true;
+  if (targetValue.trim() === String(sourceValue ?? '').trim()) {
+    return !isSafeUnchangedSourceCopy(targetValue, args);
+  }
   if (args.onlyMissingOrEnglish !== false && isLikelyEnglish(targetValue, args)) return true;
   return args.onlyMissingOrEnglish === false;
 }
@@ -410,7 +434,9 @@ function getResidualUntranslatedReason(sourceValue, targetValue, args) {
   if (isUntranslatedMarker(targetValue)) return 'marker';
   if (isBrokenTranslationValue(targetValue)) return 'broken';
   if (isLanguagePrefixedEnglish(targetValue, args)) return 'language_prefix';
-  if (targetValue.trim() === String(sourceValue ?? '').trim()) return 'source_copy';
+  if (targetValue.trim() === String(sourceValue ?? '').trim()) {
+    return isSafeUnchangedSourceCopy(targetValue, args) ? null : 'source_copy';
+  }
   return null;
 }
 

package/main/manage/commands/CommandRouter.js

@@ -157,10 +157,13 @@ class CommandRouter {
         }
 
         try {
-            // Route command to appropriate handler
-            const result = await this.routeCommand(command, options, executionContext);
-
-            // Handle command completion based on execution context
+            // Route command to appropriate handler
+            const result = await this.routeCommand(command, options, executionContext);
+            if (result && result.success === false) {
+                throw new Error(result.error || result.message || `${command} command failed`);
+            }
+
+            // Handle command completion based on execution context
             console.log('\n' + t('operations.completed'));
 
             if (isManagerExecution && !this.isNonInteractiveMode && this.prompt) {