@4399ywkf/cli 1.0.8 → 1.0.10

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

@@ -0,0 +1,344 @@
+/* eslint-disable unicorn/prefer-top-level-await */
+import { consola } from 'consola';
+import { colors } from 'consola/utils';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { IGNORED_FILES } from './protectedPatterns';
+
+interface UnusedKey {
+  filePath: string;
+  fullKey: string;
+  key: string;
+  namespace: string;
+}
+
+interface ReportData {
+  generatedAt: string;
+  statistics: {
+    totalKeys: number;
+    unusedKeys: number;
+    usageRate: string;
+    usedKeys: number;
+  };
+  unusedKeys: UnusedKey[];
+  unusedKeysByNamespace: Array<{
+    count: number;
+    keys: string[];
+    namespace: string;
+  }>;
+}
+
+/**
+ * Remove a key from a nested object
+ */
+function removeKeyFromObject(obj: any, keyPath: string): boolean {
+  const keys = keyPath.split('.');
+  const lastKey = keys.pop()!;
+
+  let current = obj;
+  const parents: Array<{ key: string; obj: any }> = [];
+
+  // Navigate to the parent of the target key
+  for (const key of keys) {
+    if (!current[key]) {
+      return false; // Key path doesn't exist
+    }
+    parents.push({ key, obj: current });
+    current = current[key];
+  }
+
+  // Remove the key
+  if (lastKey in current) {
+    delete current[lastKey];
+
+    // Clean up empty parent objects
+    for (let i = parents.length - 1; i >= 0; i--) {
+      const { obj, key } = parents[i];
+      if (Object.keys(obj[key]).length === 0) {
+        delete obj[key];
+      } else {
+        break; // Stop if parent still has other keys
+      }
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Clean unused keys from TypeScript default locale files
+ */
+function cleanDefaultLocaleFiles(unusedKeys: UnusedKey[], dryRun: boolean = true) {
+  const defaultLocalesPath = path.join(process.cwd(), 'src/locales/default');
+
+  // Get ignored namespace names from IGNORED_FILES (remove .ts extension)
+  const ignoredNamespaces = new Set(IGNORED_FILES.map((f) => f.replace('.ts', '')));
+
+  // Group by namespace
+  const byNamespace = new Map<string, string[]>();
+  for (const key of unusedKeys) {
+    // Skip ignored namespaces (from IGNORED_FILES)
+    if (ignoredNamespaces.has(key.namespace)) {
+      continue;
+    }
+
+    if (!byNamespace.has(key.namespace)) {
+      byNamespace.set(key.namespace, []);
+    }
+    byNamespace.get(key.namespace)!.push(key.key);
+  }
+
+  consola.info(`Processing ${byNamespace.size} namespace files...`);
+  consola.info('');
+
+  let totalRemoved = 0;
+
+  for (const [namespace, keys] of byNamespace.entries()) {
+    const filePath = path.join(defaultLocalesPath, `${namespace}.ts`);
+
+    if (!fs.existsSync(filePath)) {
+      consola.warn(`File not found: ${filePath}`);
+      continue;
+    }
+
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const loadedModule = require(filePath);
+      const translations = loadedModule.default || loadedModule;
+
+      // Create a deep copy to avoid modifying the original
+      const updatedTranslations = structuredClone(translations);
+
+      let removedCount = 0;
+
+      // Remove each unused key
+      for (const key of keys) {
+        if (removeKeyFromObject(updatedTranslations, key)) {
+          removedCount++;
+          totalRemoved++;
+        }
+      }
+
+      if (removedCount > 0) {
+        consola.info(
+          colors.cyan(namespace.padEnd(20)),
+          colors.gray('→'),
+          colors.red(`${removedCount} keys to remove`),
+        );
+
+        if (!dryRun) {
+          // Generate new content
+          // eslint-disable-next-line @typescript-eslint/no-use-before-define
+          const newContent = generateTypeScriptContent(updatedTranslations);
+
+          // Write back to file
+          fs.writeFileSync(filePath, newContent, 'utf8');
+          consola.success(`  ✓ Updated ${filePath}`);
+        } else {
+          consola.info(`  ${colors.gray('(dry run - no changes made)')}`);
+        }
+      }
+    } catch (error) {
+      consola.error(`Failed to process ${namespace}:`, error);
+    }
+  }
+
+  return totalRemoved;
+}
+
+/**
+ * Clean unused keys from JSON locale files
+ */
+function cleanLocaleJsonFiles(unusedKeys: UnusedKey[], dryRun: boolean = true) {
+  const localesPath = path.join(process.cwd(), 'locales');
+  const locales = fs
+    .readdirSync(localesPath)
+    .filter((f) => fs.statSync(path.join(localesPath, f)).isDirectory());
+
+  consola.info(`Processing ${locales.length} locale directories...`);
+  consola.info('');
+
+  // Get ignored namespace names from IGNORED_FILES (remove .ts extension)
+  const ignoredNamespaces = new Set(IGNORED_FILES.map((f) => f.replace('.ts', '')));
+
+  // Group by namespace
+  const byNamespace = new Map<string, string[]>();
+  for (const key of unusedKeys) {
+    // Skip ignored namespaces (from IGNORED_FILES)
+    if (ignoredNamespaces.has(key.namespace)) {
+      continue;
+    }
+
+    if (!byNamespace.has(key.namespace)) {
+      byNamespace.set(key.namespace, []);
+    }
+    byNamespace.get(key.namespace)!.push(key.key);
+  }
+
+  let totalRemoved = 0;
+
+  for (const locale of locales) {
+    consola.info(colors.cyan(`Locale: ${locale}`));
+
+    for (const [namespace, keys] of byNamespace.entries()) {
+      const filePath = path.join(localesPath, locale, `${namespace}.json`);
+
+      if (!fs.existsSync(filePath)) {
+        continue;
+      }
+
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const translations = JSON.parse(content);
+
+        let removedCount = 0;
+
+        // Remove each unused key
+        for (const key of keys) {
+          if (removeKeyFromObject(translations, key)) {
+            removedCount++;
+            totalRemoved++;
+          }
+        }
+
+        if (removedCount > 0) {
+          consola.info(
+            `  ${colors.gray(namespace.padEnd(20))} → ${colors.red(removedCount + ' keys removed')}`,
+          );
+
+          if (!dryRun) {
+            // Write back to file with pretty formatting
+            fs.writeFileSync(filePath, JSON.stringify(translations, null, 2) + '\n', 'utf8');
+          }
+        }
+      } catch (error) {
+        consola.error(`Failed to process ${locale}/${namespace}:`, error);
+      }
+    }
+
+    consola.info('');
+  }
+
+  return totalRemoved;
+}
+
+/**
+ * Check if a key needs quotes in TypeScript object notation
+ */
+function needsQuotes(key: string): boolean {
+  // Keys that need quotes:
+  // - Contains special characters (-, ., spaces, etc.)
+  // - Starts with a number
+  // - Is a reserved keyword
+  return !/^[$A-Z_a-z][\w$]*$/.test(key);
+}
+
+/**
+ * Generate TypeScript file content from object
+ */
+function generateTypeScriptContent(obj: any): string {
+  const jsonString = JSON.stringify(obj, null, 2);
+
+  // Convert JSON to TypeScript object notation
+  // Handle keys that need quotes vs those that don't
+  let tsContent = jsonString.replaceAll(/"([^"]+)":/g, (match, key) => {
+    if (needsQuotes(key)) {
+      // Keep quotes for keys with special characters
+      return `'${key}':`;
+    }
+    // Remove quotes for valid identifiers
+    return `${key}:`;
+  });
+
+  // Use single quotes for string values
+  tsContent = tsContent.replaceAll(/: "([^"]*)"/g, ": '$1'");
+
+  return `export default ${tsContent};\n`;
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const reportPath = path.join(process.cwd(), 'i18n-unused-keys-report.json');
+
+  // Check if report exists
+  if (!fs.existsSync(reportPath)) {
+    consola.error(
+      `Report file not found: ${reportPath}\n` +
+        'Please run "bun run workflow:i18n-analyze" first to generate the report.',
+    );
+    throw new Error('Report file not found');
+  }
+
+  // Load report
+  const reportContent = fs.readFileSync(reportPath, 'utf8');
+  const report: ReportData = JSON.parse(reportContent);
+
+  consola.box('🧹 Clean Unused i18n Keys');
+  consola.info('');
+
+  // Show statistics
+  consola.info(colors.cyan('Statistics from report:'));
+  consola.info(`  Total keys: ${report.statistics.totalKeys}`);
+  consola.info(`  Used keys: ${report.statistics.usedKeys}`);
+  consola.info(`  Unused keys: ${colors.red(report.statistics.unusedKeys.toString())}`);
+  consola.info(`  Usage rate: ${report.statistics.usageRate}`);
+  consola.info('');
+
+  if (report.unusedKeys.length === 0) {
+    consola.success('No unused keys to clean!');
+    return;
+  }
+
+  // Ask for confirmation
+  const args = process.argv.slice(2);
+  const dryRun = !args.includes('--no-dry-run');
+
+  if (dryRun) {
+    consola.warn('Running in DRY RUN mode - no files will be modified');
+    consola.info('To actually clean the files, run: bun run workflow:i18n-clean --no-dry-run');
+    consola.info('');
+  } else {
+    consola.warn('⚠️  WARNING: This will modify your locale files!');
+    consola.info('Make sure you have committed your changes or have a backup.');
+    consola.info('');
+  }
+
+  // Clean default locale files (TypeScript)
+  consola.box('Step 1: Cleaning default locale files (TypeScript)');
+  const removedFromDefault = cleanDefaultLocaleFiles(report.unusedKeys, dryRun);
+  consola.info('');
+
+  // Clean locale JSON files
+  consola.box('Step 2: Cleaning locale JSON files');
+  const removedFromJson = cleanLocaleJsonFiles(report.unusedKeys, dryRun);
+  consola.info('');
+
+  // Summary
+  consola.box('Summary');
+  consola.info(`Keys marked for removal: ${colors.red(report.unusedKeys.length.toString())}`);
+  consola.info(
+    `Total operations: ${colors.yellow((removedFromDefault + removedFromJson).toString())}`,
+  );
+
+  if (dryRun) {
+    consola.info('');
+    consola.warn('This was a DRY RUN - no files were modified');
+    consola.info('To actually clean the files, run:');
+    consola.info(colors.cyan('  bun run workflow:i18n-clean --no-dry-run'));
+  } else {
+    consola.success('✓ Cleanup completed!');
+    consola.info('');
+    consola.info('Next steps:');
+    consola.info('  1. Review the changes with git diff');
+    consola.info('  2. Run "bun run i18n" to regenerate all locale files');
+    consola.info('  3. Test your application');
+    consola.info('  4. Commit the changes');
+  }
+}
+
+main();

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

@@ -0,0 +1,18 @@
+import { readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import i18nConfig from './i18nConfig';
+
+export const root = resolve(__dirname, '../..');
+export const localesDir = resolve(root, i18nConfig.output);
+export const localeDir = (locale: string) => resolve(localesDir, locale);
+export const localeDirJsonList = (locale: string) =>
+  readdirSync(localeDir(locale)).filter((name) => name.includes('.json'));
+export const srcLocalesDir = resolve(root, './src/locales');
+export const entryLocaleJsonFilepath = (file: string) =>
+  resolve(localesDir, i18nConfig.entryLocale, file);
+export const outputLocaleJsonFilepath = (locale: string, file: string) =>
+  resolve(localesDir, locale, file);
+export const srcDefaultLocales = resolve(root, srcLocalesDir, 'default');
+
+export { default as i18nConfig } from './i18nConfig';

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

@@ -0,0 +1,139 @@
+/* eslint-disable unicorn/prefer-top-level-await */
+import prettier from '@prettier/sync';
+import { consola } from 'consola';
+import { colors } from 'consola/utils';
+import { readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { toLodashPath } from '../../src/locales/utils';
+import { localeDir, localeDirJsonList, localesDir, srcDefaultLocales } from './const';
+
+const prettierOptions = prettier.resolveConfig(resolve(__dirname, '../../.prettierrc.js')) ?? {};
+
+const DEFAULT_SKIP_FILES = new Set(['index.ts', 'models.ts', 'providers.ts']);
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (!value || typeof value !== 'object') return false;
+  return Object.prototype.toString.call(value) === '[object Object]';
+};
+
+const shouldPreserveObject = (value: Record<string, unknown>) => {
+  const keys = Object.keys(value);
+  if (keys.length === 0) return true;
+  return keys.every((key) => /^\d+$/.test(key));
+};
+
+const flattenObject = (input: Record<string, unknown>) => {
+  const output: Record<string, unknown> = {};
+
+  const addEntry = (pathSegments: Array<number | string>, value: unknown) => {
+    const key = toLodashPath(pathSegments);
+    if (Object.prototype.hasOwnProperty.call(output, key)) {
+      throw new Error(`Duplicate i18n key detected: ${key}`);
+    }
+    output[key] = value;
+  };
+
+  const visit = (value: unknown, pathSegments: Array<number | string>) => {
+    if (Array.isArray(value)) {
+      addEntry(pathSegments, value);
+      return;
+    }
+
+    if (isPlainObject(value)) {
+      if (shouldPreserveObject(value)) {
+        addEntry(pathSegments, value);
+        return;
+      }
+
+      const entries = Object.entries(value);
+      if (entries.length === 0) {
+        addEntry(pathSegments, value);
+        return;
+      }
+
+      for (const [childKey, childValue] of entries) {
+        visit(childValue, [...pathSegments, childKey]);
+      }
+      return;
+    }
+
+    addEntry(pathSegments, value);
+  };
+
+  for (const [key, value] of Object.entries(input)) {
+    visit(value, [key]);
+  }
+
+  return output;
+};
+
+const writeTs = (filePath: string, data: Record<string, unknown>) => {
+  const content = `export default ${JSON.stringify(data, null, 2)};\n`;
+  const formatted = prettier.format(content, {
+    ...prettierOptions,
+    parser: 'typescript',
+  });
+  writeFileSync(filePath, formatted, 'utf8');
+};
+
+const writeJson = (filePath: string, data: Record<string, unknown>) => {
+  const json = JSON.stringify(data, null, 2);
+  const formatted = prettier.format(json, {
+    ...prettierOptions,
+    parser: 'json',
+  });
+  writeFileSync(filePath, formatted, 'utf8');
+};
+
+const flattenDefaultLocales = async () => {
+  const files = readdirSync(srcDefaultLocales).filter((file) => file.endsWith('.ts'));
+
+  for (const file of files) {
+    if (DEFAULT_SKIP_FILES.has(file)) continue;
+
+    const filePath = resolve(srcDefaultLocales, file);
+    const fileUrl = pathToFileURL(filePath).href;
+    const loaded = await import(fileUrl);
+    const data = loaded.default ?? loaded;
+
+    const flat = flattenObject(data as Record<string, unknown>);
+    writeTs(filePath, flat);
+    consola.success(colors.cyan(file), colors.gray('flattened'));
+  }
+};
+
+const flattenLocaleJsons = () => {
+  const localeFolders = readdirSync(localesDir).filter((dir) =>
+    statSync(localeDir(dir)).isDirectory(),
+  );
+
+  for (const locale of localeFolders) {
+    const jsonFiles = localeDirJsonList(locale);
+    for (const jsonFile of jsonFiles) {
+      const filePath = resolve(localeDir(locale), jsonFile);
+      const raw = readFileSync(filePath, 'utf8');
+      const data = JSON.parse(raw);
+      const flat = flattenObject(data);
+      writeJson(filePath, flat);
+      consola.success(colors.cyan(`${locale}/${jsonFile}`), colors.gray('flattened'));
+    }
+  }
+};
+
+const run = async () => {
+  consola.start('Flattening src/locales/default...');
+  await flattenDefaultLocales();
+
+  consola.start('Flattening locales JSON files...');
+  flattenLocaleJsons();
+
+  consola.success('Flattening completed.');
+};
+
+run().catch((error) => {
+  consola.error(error);
+  // eslint-disable-next-line unicorn/no-process-exit
+  process.exit(1);
+});

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

@@ -0,0 +1,19 @@
+import { consola } from 'consola';
+import { colors } from 'consola/utils';
+
+import { entryLocaleJsonFilepath, i18nConfig, srcDefaultLocales } from './const';
+import { tagWhite, writeJSONWithPrettier } from './utils';
+
+export const genDefaultLocale = () => {
+  consola.info(`Default locale is ${i18nConfig.entryLocale}...`);
+
+  const resources = require(srcDefaultLocales);
+  const data = Object.entries(resources.default);
+  consola.start(`Generate default locale json, found ${data.length} namespaces...`);
+
+  for (const [ns, value] of data) {
+    const filepath = entryLocaleJsonFilepath(`${ns}.json`);
+    writeJSONWithPrettier(filepath, value);
+    consola.success(tagWhite(ns), colors.gray(filepath));
+  }
+};

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

@@ -0,0 +1,49 @@
+import { consola } from 'consola';
+import { colors } from 'consola/utils';
+import { unset } from 'es-toolkit/compat';
+import { diff } from 'just-diff';
+import { existsSync } from 'node:fs';
+
+import {
+  entryLocaleJsonFilepath,
+  i18nConfig,
+  outputLocaleJsonFilepath,
+  srcDefaultLocales,
+} from './const';
+import { readJSON, tagWhite, writeJSONWithPrettier } from './utils';
+
+export const genDiff = () => {
+  consola.start(`Remove diff analysis...`);
+
+  const resources = require(srcDefaultLocales);
+  const data = Object.entries(resources.default);
+
+  for (const [ns, devJSON] of data) {
+    const filepath = entryLocaleJsonFilepath(`${ns}.json`);
+    if (!existsSync(filepath)) continue;
+    const previousProdJSON = readJSON(filepath);
+
+    const diffResult = diff(previousProdJSON, devJSON as any);
+    if (diffResult.length === 0) {
+      consola.success(tagWhite(ns), colors.gray(filepath));
+      continue;
+    }
+
+    const clearLocals = [];
+
+    for (const locale of i18nConfig.outputLocales) {
+      const localeFilepath = outputLocaleJsonFilepath(locale, `${ns}.json`);
+      if (!existsSync(localeFilepath)) continue;
+      const localeJSON = readJSON(localeFilepath);
+
+      for (const item of diffResult) {
+        unset(localeJSON, item.path);
+      }
+
+      writeJSONWithPrettier(localeFilepath, localeJSON);
+      clearLocals.push(locale);
+    }
+    consola.info('clear', clearLocals);
+    consola.success(tagWhite(ns), colors.gray(filepath));
+  }
+};

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

@@ -0,0 +1,7 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+const config = require('../../.i18nrc');
+
+export default config;

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

@@ -0,0 +1,11 @@
+import { genDefaultLocale } from './genDefaultLocale';
+import { genDiff } from './genDiff';
+import { split } from './utils';
+
+split('DIFF ANALYSIS');
+genDiff();
+
+split('GENERATE DEFAULT LOCALE');
+genDefaultLocale();
+
+split('GENERATE I18N FILES');

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

@@ -0,0 +1,91 @@
+/**
+ * Protected patterns for i18n keys
+ *
+ * Keys matching these patterns will be considered "used" even if not found in static analysis.
+ * This is useful for dynamically generated keys like:
+ * - t(`modelProvider.${providerId}.title`)
+ * - t('error.' + errorCode)
+ */
+
+/**
+ * Files to ignore at file level (won't be scanned at all)
+ */
+export const IGNORED_FILES = [
+  'providers.ts', // Dynamically generated from DEFAULT_MODEL_PROVIDER_LIST
+  'models.ts', // Dynamically generated from LOBE_DEFAULT_MODEL_LIST
+  'auth.ts', // Auth-related dynamic keys
+  'authError.ts', // Auth error dynamic keys
+  'error.ts', // Error messages with dynamic codes
+  'migration.ts', // Migration-related dynamic keys
+  'subscription.ts',
+  'electron.ts', // Electron-specific dynamic keys
+  'editor.ts', // Editor-related dynamic keys
+  'changelog.ts', // Changelog dynamic keys
+  'ragEval.ts',
+  'plugin.ts',
+  'tools.ts',
+  'oauth.ts',
+];
+
+/**
+ * Namespace patterns to protect (keys won't be marked as unused)
+ */
+export const PROTECTED_KEY_PATTERNS = [
+  // === Namespaces with extensive dynamic usage ===
+  'modelProvider', // t(`modelProvider.${providerId}.title`)
+
+  // Discover namespace has many dynamic keys
+  'discover', // t(`assistants.status.${statusKey}.subtitle`)
+
+  // Setting namespace with dynamic agent configurations
+  'setting', // t(`systemAgent.${key}.label`)
+
+  // Hotkey namespace uses dynamic key construction
+  'hotkey', // t(`${item.id}.desc`, { ns: 'hotkey' })
+
+  // Home namespace with dynamic starter keys
+  'home', // t(`starter.${key}`)
+
+  // Welcome namespace with returnObjects usage
+  'welcome', // t('welcomeMessages', { returnObjects: true })
+
+  // Chat namespace has dynamic input keys
+  'chat', // t(`input.${key}`)
+
+  // File namespace - used in hooks that receive t as parameter
+  'file', // TFunction<'file'> passed as parameter
+
+  // MarketAuth namespace - has Trans components with dynamic keys
+  'marketAuth', // <Trans i18nKey="authorize.footer.agreement" />
+
+  // Onboarding namespace - has various dynamic usage patterns
+  'onboarding', // Onboarding flow with complex Trans usage
+  'error',
+  'errors',
+  'consent.error',
+  'builtins',
+
+  // === Add your custom patterns here ===
+  // Examples:
+  // 'error.code',           // Protects all error.code.* keys
+  // 'plugin.settings',      // Protects all plugin.settings.* keys
+  // 'tool',                 // Protects entire 'tool' namespace
+];
+
+/**
+ * How to use:
+ *
+ * 1. IGNORED_FILES - Files to completely skip during analysis:
+ *    Add filename with .ts extension (e.g., 'auth.ts')
+ *    These files won't be scanned at all
+ *
+ * 2. PROTECTED_KEY_PATTERNS - Namespace/patterns to protect:
+ *    - Full namespace: 'myNamespace' protects all keys under that namespace
+ *    - Prefix pattern: 'namespace.prefix' protects keys starting with that prefix
+ *      (e.g., 'error.code' protects 'error.code.NOT_FOUND', 'error.code.TIMEOUT', etc.)
+ *
+ * 3. After modifying this file:
+ *    - Run `bun run workflow:i18n-analyze` to regenerate the report
+ *    - Run `bun run workflow:i18n-clean` to preview cleanup (both use same config)
+ *    - Check the console output for "Protected patterns" to verify your config
+ */