@4399ywkf/cli 1.0.8 → 1.0.10

package/dist/templates/app/scripts/i18nWorkflow/analyzeUnusedKeys.ts

@@ -0,0 +1,506 @@
+/* eslint-disable unicorn/prefer-top-level-await */
+import { consola } from 'consola';
+import { colors } from 'consola/utils';
+import { glob } from 'glob';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { IGNORED_FILES, PROTECTED_KEY_PATTERNS } from './protectedPatterns';
+
+interface I18nKey {
+  fullKey: string;
+  key: string;
+  namespace: string;
+}
+
+interface UnusedKey extends I18nKey {
+  filePath: string;
+}
+
+/**
+ * Check if a key should be protected (considered as "used")
+ */
+function isProtectedKey(namespace: string, key: string): boolean {
+  // Check if namespace is in protected list
+  if (PROTECTED_KEY_PATTERNS.includes(namespace)) {
+    return true;
+  }
+
+  // Check if key matches any protected pattern
+  const fullKey = `${namespace}.${key}`;
+  return PROTECTED_KEY_PATTERNS.some((pattern) => {
+    // Exact namespace match
+    if (pattern === namespace) return true;
+    // Partial key match (e.g., "error.code" matches "error.code.NOT_FOUND")
+    if (fullKey.startsWith(pattern + '.')) return true;
+    return false;
+  });
+}
+
+/**
+ * Recursively extract all keys from a nested object
+ */
+function extractKeysFromObject(obj: any, namespace: string, prefix: string = ''): I18nKey[] {
+  const keys: I18nKey[] = [];
+
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      // Recursively extract keys from nested objects
+      keys.push(...extractKeysFromObject(value, namespace, fullKey));
+    } else {
+      // This is a leaf node (actual translation)
+      keys.push({
+        fullKey: `${namespace}:${fullKey}`,
+        key: fullKey,
+        namespace,
+      });
+    }
+  }
+
+  return keys;
+}
+
+/**
+ * Load all i18n keys from src/locales/default
+ */
+function loadAllI18nKeys(): I18nKey[] {
+  const defaultLocalesPath = path.join(process.cwd(), 'src/locales/default');
+  const allKeys: I18nKey[] = [];
+
+  // Get all TypeScript files except index.ts and ignored files
+  const ignoredFiles: string[] = [...IGNORED_FILES];
+  const files = fs
+    .readdirSync(defaultLocalesPath)
+    .filter((f) => f.endsWith('.ts') && f !== 'index.ts' && !ignoredFiles.includes(f));
+
+  consola.info(`Found ${files.length} namespace files (ignored: ${ignoredFiles.join(', ')})`);
+
+  for (const file of files) {
+    const namespace = path.basename(file, '.ts');
+    const filePath = path.join(defaultLocalesPath, file);
+
+    try {
+      // Use require to load the TypeScript file (after it's compiled)
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const loadedModule = require(filePath);
+      const translations = loadedModule.default || loadedModule;
+
+      const keys = extractKeysFromObject(translations, namespace);
+      allKeys.push(...keys);
+
+      consola.success(colors.cyan(namespace.padEnd(20)), colors.gray(`${keys.length} keys`));
+    } catch (error) {
+      consola.error(`Failed to load ${file}:`, error);
+    }
+  }
+
+  return allKeys;
+}
+
+/**
+ * Find all t() function calls in the codebase
+ */
+async function findAllTranslationCalls(): Promise<Set<string>> {
+  const usedKeys = new Set<string>();
+
+  // Patterns to search for translation calls
+  const patterns = [
+    'src/**/*.{ts,tsx,js,jsx}',
+    'apps/desktop/src/**/*.{ts,tsx,js,jsx}',
+    'packages/**/src/**/*.{ts,tsx,js,jsx}', // Include packages directory
+    '!**/*.test.{ts,tsx}',
+    '!**/*.spec.{ts,tsx}',
+    '!**/node_modules/**',
+    '!**/.next/**',
+  ];
+
+  consola.start('Scanning codebase for translation calls...');
+
+  const files = await glob(patterns);
+  consola.info(`Found ${files.length} files to scan`);
+
+  // Regular expressions to match translation calls
+  // Mark dynamic patterns with special flag to handle them differently
+  const regexPatterns: Array<{
+    // Whether this pattern captures dynamic keys
+    captureNs?: boolean;
+    isDynamic?: boolean;
+    pattern: RegExp; // Whether pattern can capture namespace
+  }> = [
+    // Static patterns
+    { pattern: /\bt[A-Z]?\w*\(\s*["'`]([^"'`]+)["'`]/g },
+    {
+      captureNs: true,
+      pattern: /\bt[A-Z]?\w*\(\s*["'`]([^"'`]+)["'`]\s*,\s*{[^}]*ns:\s*["'`]([^"'`]+)["'`]/g,
+    },
+    { pattern: /i18n\.t\(\s*["'`]([^"'`]+)["'`]/g },
+    { pattern: /\bt[A-Z]?\w*\([^)]*\?\s*["'`]([^"'`]+)["'`]/g },
+    { pattern: /\bt[A-Z]?\w*\([^)]*:\s*["'`]([^"'`]+)["'`]/g },
+    { pattern: /<Trans[^>]+i18nKey=["']([^"']+)["']/g },
+    { pattern: /<Trans[^>]+i18nKey={["']([^"']+)["']}/g },
+    { captureNs: true, pattern: /<Trans[^>]+i18nKey=["']([^"']+)["'][\S\s]*?ns=["']([^"']+)["']/g },
+    {
+      captureNs: true,
+      pattern: /<Trans[^>]+i18nKey={["']([^"']+)["']}[\S\s]*?ns={["']([^"']+)["']}/g,
+    },
+
+    // Dynamic patterns (template strings, concatenations, etc.)
+    // Pattern 1: t(`prefix.${var}.suffix`) - variable in the middle
+    { captureNs: false, isDynamic: true, pattern: /\bt[A-Z]?\w*\(\s*`([^$`]+)\${[^}]+}([^`]*)`/g },
+    // Pattern 2: t(`${var}.suffix`) - variable at the start
+    { captureNs: false, isDynamic: true, pattern: /\bt[A-Z]?\w*\(\s*`\${[^}]+}([^`]+)`/g },
+    // Pattern 3: t(`prefix.${var}.suffix`, { ns: 'namespace' }) - with explicit ns
+    {
+      captureNs: true,
+      isDynamic: true,
+      pattern: /\bt[A-Z]?\w*\(\s*`([^$`]*)\${[^}]+}([^`]*)`\s*,\s*{[^}]*ns:\s*["'`]([^"'`]+)["'`]/g,
+    },
+    // Pattern 4: t(`${var}.suffix`, { ns: 'namespace' }) - variable at start with ns
+    {
+      captureNs: true,
+      isDynamic: true,
+      pattern: /\bt[A-Z]?\w*\(\s*`\${[^}]+}([^`]+)`\s*,\s*{[^}]*ns:\s*["'`]([^"'`]+)["'`]/g,
+    },
+    // Pattern 5: String concatenation
+    { isDynamic: true, pattern: /\bt[A-Z]?\w*\(\s*["'`]([^"'`]+)["'`]\s*\+/g },
+    // Pattern 6: <Trans> with dynamic keys
+    { isDynamic: true, pattern: /<Trans[^>]+i18nKey={`([^$`]+)\${[^}]+}([^`]*)`}/g },
+  ];
+
+  let totalMatches = 0;
+
+  for (const file of files) {
+    const content = fs.readFileSync(file, 'utf8');
+
+    // Extract namespace from useTranslation hook
+    const useTranslationMatch = content.match(/useTranslation\(\s*["'`]([^"'`]+)["'`]\s*\)/g);
+    const useTranslationMultiMatch = content.match(/useTranslation\(\s*\[([^\]]+)]\s*\)/g);
+
+    // Extract aliases: const { t: tAuth } = useTranslation('auth')
+    const aliasPattern =
+      /const\s*{\s*t\s*:\s*(\w+)\s*}\s*=\s*useTranslation\(\s*["'`]([^"'`]+)["'`]\s*\)/g;
+    const aliasMatches = content.matchAll(aliasPattern);
+
+    const namespacesInFile = new Set<string>();
+    const aliasToNamespace = new Map<string, string>();
+
+    // Extract namespaces from useTranslation('namespace')
+    if (useTranslationMatch) {
+      for (const match of useTranslationMatch) {
+        const ns = match.match(/["'`]([^"'`]+)["'`]/)?.[1];
+        if (ns) namespacesInFile.add(ns);
+      }
+    }
+
+    // Extract namespaces from useTranslation(['ns1', 'ns2'])
+    if (useTranslationMultiMatch) {
+      for (const match of useTranslationMultiMatch) {
+        const nsArray = match.match(/\[([^\]]+)]/)?.[1];
+        if (nsArray) {
+          const namespaces = nsArray.match(/["'`]([^"'`]+)["'`]/g);
+          if (namespaces) {
+            for (const ns of namespaces) {
+              const cleanNs = ns.replaceAll(/["'`]/g, '');
+              namespacesInFile.add(cleanNs);
+            }
+          }
+        }
+      }
+    }
+
+    // Extract alias mappings (e.g., tAuth -> 'auth')
+    for (const match of aliasMatches) {
+      const alias = match[1];
+      const namespace = match[2];
+      aliasToNamespace.set(alias, namespace);
+      namespacesInFile.add(namespace);
+    }
+
+    // Find all t() calls
+    for (const { pattern: regex, captureNs, isDynamic } of regexPatterns) {
+      const matches = content.matchAll(regex);
+
+      for (const match of matches) {
+        totalMatches++;
+        const fullMatch = match[0];
+        const key = match[1];
+        let explicitNs: string | undefined;
+
+        // For patterns with captureNs, namespace is in a different position
+        if (captureNs && isDynamic) {
+          // Dynamic patterns with ns: match[1] + match[2] = key parts, match[3] = ns
+          explicitNs = match[3] || match[2]; // Try match[3] first, fall back to match[2]
+        } else if (captureNs) {
+          // Static patterns with ns: match[1] = key, match[2] = ns
+          explicitNs = match[2];
+        }
+
+        if (!key) continue;
+
+        // Extract function name (t, tAuth, tCommon, etc.)
+        const funcNameMatch = fullMatch.match(/\b(t[A-Z]?\w*)\(/);
+        const funcName = funcNameMatch?.[1] || 't';
+
+        // Check if it's an alias with known namespace
+        let aliasNamespace: string | undefined;
+        if (funcName !== 't' && aliasToNamespace.has(funcName)) {
+          aliasNamespace = aliasToNamespace.get(funcName);
+        }
+
+        // Handle dynamic keys differently
+        if (isDynamic) {
+          // For dynamic patterns, extract the static prefix/suffix
+          // e.g., t(`mcp.details.${var}.title`) -> "mcp.details." and ".title"
+          // e.g., t(`${var}.title`) -> ".title"
+          let prefix = '';
+          let suffix = '';
+
+          if (match[2] !== undefined) {
+            // Pattern has both prefix and suffix: match[1] = prefix, match[2] = suffix
+            prefix = match[1] || '';
+            suffix = match[2] || '';
+          } else {
+            // Pattern has only suffix (var at start): match[1] = suffix
+            suffix = match[1] || '';
+          }
+
+          // Combine prefix and suffix for the pattern
+          const pattern = (prefix + suffix).trim();
+          if (!pattern) continue; // Skip if nothing to protect
+
+          // Determine the namespace
+          let targetNs: string | undefined;
+          if (aliasNamespace) {
+            targetNs = aliasNamespace;
+          } else if (explicitNs) {
+            targetNs = explicitNs;
+          } else if (namespacesInFile.size === 1) {
+            targetNs = [...namespacesInFile][0];
+          } else if (namespacesInFile.size > 0) {
+            // Multiple namespaces, add prefix pattern for each
+            for (const ns of namespacesInFile) {
+              usedKeys.add(`${ns}:${pattern}*`);
+            }
+            continue;
+          }
+
+          if (targetNs) {
+            usedKeys.add(`${targetNs}:${pattern}*`);
+          }
+          continue;
+        }
+
+        // Handle static keys
+        if (explicitNs) {
+          // Has explicit namespace
+          usedKeys.add(`${explicitNs}:${key}`);
+        } else if (aliasNamespace) {
+          // Using alias (e.g., tAuth('key'))
+          usedKeys.add(`${aliasNamespace}:${key}`);
+        } else if (key.includes(':')) {
+          // Key already includes namespace (e.g., t('common:key'))
+          usedKeys.add(key);
+        } else {
+          // Use namespaces from useTranslation hook
+          if (namespacesInFile.size > 0) {
+            for (const ns of namespacesInFile) {
+              usedKeys.add(`${ns}:${key}`);
+            }
+          } else {
+            // Default to 'common' if no namespace found
+            usedKeys.add(`common:${key}`);
+          }
+        }
+      }
+    }
+  }
+
+  consola.success(`Found ${totalMatches} translation calls`);
+  consola.info(`Extracted ${usedKeys.size} unique keys`);
+
+  return usedKeys;
+}
+
+/**
+ * Find unused i18n keys
+ */
+function findUnusedKeys(allKeys: I18nKey[], usedKeys: Set<string>): UnusedKey[] {
+  const unused: UnusedKey[] = [];
+  const protectedKeys: UnusedKey[] = [];
+
+  // Extract prefix patterns from usedKeys
+  // e.g., "discover:mcp.details.*" means any key starting with "mcp.details." in discover namespace
+  const prefixPatterns: Array<{ namespace: string; prefix: string }> = [];
+  for (const key of usedKeys) {
+    if (key.includes('*')) {
+      const [namespace, pattern] = key.split(':');
+      const prefix = pattern.replace(/\*$/, ''); // Remove trailing *
+      prefixPatterns.push({ namespace, prefix });
+    }
+  }
+
+  for (const keyInfo of allKeys) {
+    // Check if key is protected by configuration
+    if (isProtectedKey(keyInfo.namespace, keyInfo.key)) {
+      protectedKeys.push({
+        ...keyInfo,
+        filePath: `src/locales/default/${keyInfo.namespace}.ts`,
+      });
+      continue;
+    }
+
+    // Check if key matches any prefix pattern (from dynamic usage)
+    let matchesPrefix = false;
+    for (const { namespace, prefix } of prefixPatterns) {
+      if (keyInfo.namespace === namespace && keyInfo.key.startsWith(prefix)) {
+        matchesPrefix = true;
+        break;
+      }
+    }
+
+    if (matchesPrefix) {
+      protectedKeys.push({
+        ...keyInfo,
+        filePath: `src/locales/default/${keyInfo.namespace}.ts`,
+      });
+      continue;
+    }
+
+    // Check if key is actually used
+    if (!usedKeys.has(keyInfo.fullKey)) {
+      unused.push({
+        ...keyInfo,
+        filePath: `src/locales/default/${keyInfo.namespace}.ts`,
+      });
+    }
+  }
+
+  if (protectedKeys.length > 0) {
+    consola.info('');
+    consola.info(colors.cyan('Protected keys (considered as used):'));
+    consola.info(
+      `  ${colors.green(protectedKeys.length.toString())} keys protected by patterns or dynamic usage`,
+    );
+  }
+
+  return unused;
+}
+
+/**
+ * Generate report
+ */
+function generateReport(unusedKeys: UnusedKey[], allKeysCount: number, usedKeysCount: number) {
+  consola.box('📊 Unused i18n Keys Analysis Report');
+
+  const actualUsedCount = allKeysCount - unusedKeys.length;
+
+  consola.info('');
+  consola.info(colors.cyan('Statistics:'));
+  consola.info(`  Total defined keys: ${colors.yellow(allKeysCount.toString())}`);
+  consola.info(`  Used keys: ${colors.green(actualUsedCount.toString())}`);
+  consola.info(`  Unused keys: ${colors.red(unusedKeys.length.toString())}`);
+  consola.info(
+    `  Usage rate: ${colors.cyan(((actualUsedCount / allKeysCount) * 100).toFixed(2) + '%')}`,
+  );
+  consola.info('');
+  consola.info(colors.gray('Protected patterns:'));
+  consola.info(`  ${colors.gray(PROTECTED_KEY_PATTERNS.map((p) => `"${p}"`).join(', '))}`);
+  consola.info('');
+
+  if (unusedKeys.length === 0) {
+    consola.success('🎉 All i18n keys are being used!');
+    return;
+  }
+
+  // Group by namespace
+  const byNamespace = new Map<string, UnusedKey[]>();
+  for (const key of unusedKeys) {
+    if (!byNamespace.has(key.namespace)) {
+      byNamespace.set(key.namespace, []);
+    }
+    byNamespace.get(key.namespace)!.push(key);
+  }
+
+  consola.info(colors.yellow('Unused keys by namespace:'));
+  consola.info('');
+
+  for (const [namespace, keys] of byNamespace.entries()) {
+    consola.warn(
+      `${colors.cyan(namespace.padEnd(20))} ${colors.gray('→')} ${colors.red(keys.length + ' unused keys')}`,
+    );
+
+    // Show first 10 keys
+    const displayKeys = keys.slice(0, 10);
+    for (const key of displayKeys) {
+      consola.log(`    ${colors.gray('•')} ${key.key}`);
+    }
+
+    if (keys.length > 10) {
+      consola.log(`    ${colors.gray(`... and ${keys.length - 10} more`)}`);
+    }
+    consola.info('');
+  }
+
+  // Save detailed report to file
+  const reportPath = path.join(process.cwd(), 'i18n-unused-keys-report.json');
+  fs.writeFileSync(
+    reportPath,
+    JSON.stringify(
+      {
+        generatedAt: new Date().toISOString(),
+        statistics: {
+          totalKeys: allKeysCount,
+          unusedKeys: unusedKeys.length,
+          usageRate: ((usedKeysCount / allKeysCount) * 100).toFixed(2) + '%',
+          usedKeys: usedKeysCount,
+        },
+        unusedKeys: unusedKeys.map((k) => ({
+          filePath: k.filePath,
+          fullKey: k.fullKey,
+          key: k.key,
+          namespace: k.namespace,
+        })),
+        unusedKeysByNamespace: Array.from(byNamespace.entries()).map(([ns, keys]) => ({
+          count: keys.length,
+          keys: keys.map((k) => k.key),
+          namespace: ns,
+        })),
+      },
+      null,
+      2,
+    ),
+  );
+
+  consola.success(`Detailed report saved to: ${colors.cyan(reportPath)}`);
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  consola.start('Starting i18n unused keys analysis...');
+  consola.info('');
+
+  // Step 1: Load all defined keys
+  consola.box('Step 1: Loading all i18n keys');
+  const allKeys = loadAllI18nKeys();
+  consola.success(`Total keys loaded: ${allKeys.length}`);
+  consola.info('');
+
+  // Step 2: Find all translation calls
+  consola.box('Step 2: Finding translation calls in codebase');
+  const usedKeys = await findAllTranslationCalls();
+  consola.info('');
+
+  // Step 3: Find unused keys
+  consola.box('Step 3: Analyzing unused keys');
+  const unusedKeys = findUnusedKeys(allKeys, usedKeys);
+  consola.info('');
+
+  // Step 4: Generate report
+  generateReport(unusedKeys, allKeys.length, usedKeys.size);
+}
+
+main();