create-forgeon 0.1.20 → 0.1.22

package/README.md

@@ -1,8 +1,14 @@
-# create-forgeon
-
-CLI package for generating Forgeon fullstack monorepo projects.
-
-## Usage
+# create-forgeon
+
+CLI package for generating Forgeon fullstack monorepo projects.
+
+> [!WARNING]
+> **Pre-release package. Do not use in production before `1.0.0`.**
+> The project is under active development: each patch can add changes and may introduce breaking regressions.
+>
+> ![warning](https://img.shields.io/badge/STATUS-PRE--RELEASE%20DO%20NOT%20USE-red)
+
+## Usage
 
 ```bash
 npx create-forgeon@latest my-app --i18n true --proxy caddy

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-forgeon",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Forgeon project generator CLI",
   "license": "MIT",
   "author": "Forgeon",

package/src/modules/executor.test.mjs

@@ -161,6 +161,15 @@ describe('addModule', () => {
         'utf8',
       );
       assert.match(i18nWebSource, /@forgeon\/i18n-contracts/);
+      assert.doesNotMatch(i18nWebSource, /I18N_DEFAULT_LANG/);
+
+      const i18nContractsIndex = fs.readFileSync(
+        path.join(projectRoot, 'packages', 'i18n-contracts', 'src', 'index.ts'),
+        'utf8',
+      );
+      assert.match(i18nContractsIndex, /from '\.\/generated'/);
+      assert.doesNotMatch(i18nContractsIndex, /I18N_DEFAULT_LANG/);
+      assert.doesNotMatch(i18nContractsIndex, /I18N_FALLBACK_LANG/);
 
       const enCommon = JSON.parse(
         fs.readFileSync(path.join(projectRoot, 'resources', 'i18n', 'en', 'common.json'), 'utf8'),
@@ -183,9 +192,12 @@ describe('addModule', () => {
       const i18nTs = fs.readFileSync(path.join(projectRoot, 'apps', 'web', 'src', 'i18n.ts'), 'utf8');
       assert.match(i18nTs, /initReactI18next/);
       assert.match(i18nTs, /\.\.\/\.\.\/\.\.\/resources\/i18n\/en\/common\.json/);
+      assert.doesNotMatch(i18nTs, /I18N_DEFAULT_LANG/);
 
       const rootPackage = fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8');
+      assert.match(rootPackage, /"i18n:sync"/);
       assert.match(rootPackage, /"i18n:check"/);
+      assert.match(rootPackage, /"i18n:types"/);
 
       const caddyDockerfile = fs.readFileSync(
         path.join(projectRoot, 'infra', 'docker', 'caddy.Dockerfile'),

package/src/modules/i18n.mjs

@@ -279,7 +279,21 @@ function patchRootPackage(targetRoot) {
   }
 
   const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-  ensureScript(packageJson, 'i18n:check', 'pnpm --filter @forgeon/i18n-contracts check:keys');
+  ensureScript(
+    packageJson,
+    'i18n:sync',
+    'pnpm --filter @forgeon/i18n-contracts i18n:sync',
+  );
+  ensureScript(
+    packageJson,
+    'i18n:check',
+    'pnpm --filter @forgeon/i18n-contracts i18n:check',
+  );
+  ensureScript(
+    packageJson,
+    'i18n:types',
+    'pnpm --filter @forgeon/i18n-contracts i18n:types',
+  );
   writeJson(packagePath, packageJson);
 }
 

package/src/presets/i18n.mjs

@@ -87,7 +87,20 @@ export function applyI18nDisabled(targetRoot) {
   if (fs.existsSync(rootPackagePath)) {
     const rootPackage = JSON.parse(fs.readFileSync(rootPackagePath, 'utf8'));
     if (rootPackage.scripts) {
+      if (typeof rootPackage.scripts.postinstall === 'string') {
+        const nextPostinstall = rootPackage.scripts.postinstall
+          .replace(/\s*&&\s*pnpm i18n:sync/g, '')
+          .replace(/pnpm i18n:sync\s*&&\s*/g, '')
+          .trim();
+        if (nextPostinstall.length === 0) {
+          delete rootPackage.scripts.postinstall;
+        } else {
+          rootPackage.scripts.postinstall = nextPostinstall;
+        }
+      }
+      delete rootPackage.scripts['i18n:sync'];
       delete rootPackage.scripts['i18n:check'];
+      delete rootPackage.scripts['i18n:types'];
     }
     writeJson(rootPackagePath, rootPackage);
   }

package/templates/docs-fragments/AI_PROJECT/33_i18n_notes.md

@@ -2,5 +2,7 @@
 
 - i18n is enabled when the module is installed via scaffold/add flow.
 - Default/fallback are controlled by `I18N_DEFAULT_LANG` and `I18N_FALLBACK_LANG`.
-- Locale contracts live in `@forgeon/i18n-contracts`.
+- Locale contracts (`I18N_LOCALES`, `I18N_NAMESPACES`) are generated from `resources/i18n/*` via `pnpm i18n:sync`.
+- Contract validation is available via `pnpm i18n:check`.
+- Translation key type generation is available via `pnpm i18n:types`.
 - Frontend helpers live in `@forgeon/i18n-web`.

package/templates/docs-fragments/README/40_i18n.md

@@ -16,5 +16,11 @@ Packages:
 Dictionary key validation:
 - `pnpm i18n:check`
 
+Locale/namespace contracts sync:
+- `pnpm i18n:sync`
+
+Translation key types generation (manual):
+- `pnpm i18n:types`
+
 You can apply i18n later with:
 `npx create-forgeon@latest add i18n --project .`

package/templates/module-fragments/i18n/10_overview.md

@@ -4,7 +4,12 @@ Adds optional i18n support across backend and frontend.
 
 Included parts:
 - `@forgeon/i18n` (NestJS i18n integration package)
-- `@forgeon/i18n-contracts` (shared locale/query constants and key checks)
+- `@forgeon/i18n-contracts` (generated locale/namespace contracts + checks/types scripts)
 - `@forgeon/i18n-web` (React-side locale helpers)
 - `react-i18next` integration for frontend translations
 - shared dictionaries in `resources/i18n/*` (`en`, `uk`) used by both API and web
+
+Utility commands:
+- `pnpm i18n:sync` - regenerate `I18N_LOCALES` and `I18N_NAMESPACES` from `resources/i18n`.
+- `pnpm i18n:check` - verify generated contracts, JSON validity, and missing/extra keys vs fallback locale.
+- `pnpm i18n:types` - generate translation key type unions for autocomplete.

package/templates/module-fragments/i18n/20_scope.md

@@ -6,4 +6,7 @@
 - Frontend `react-i18next` setup (`apps/web/src/i18n.ts`)
 - Frontend language selector and translated UI in `apps/web/src/App.tsx`
 - Frontend package/deps/scripts updates for i18n helpers
-- Root script `i18n:check` for dictionary key consistency across locales
+- Root scripts:
+- `i18n:sync` for locale/namespace contracts sync from `resources/i18n`
+- `i18n:check` for contract/json/key consistency checks
+- `i18n:types` for translation key type generation

package/templates/module-presets/i18n/apps/web/src/i18n.ts

@@ -1,7 +1,6 @@
 import i18n from 'i18next';
 import { initReactI18next } from 'react-i18next';
-import { I18N_DEFAULT_LANG } from '@forgeon/i18n-contracts';
-import { getInitialLocale } from '@forgeon/i18n-web';
+import { getInitialLocale, I18N_LOCALES, type I18nLocale } from '@forgeon/i18n-web';
 import enCommon from '../../../resources/i18n/en/common.json';
 import enErrors from '../../../resources/i18n/en/errors.json';
 import enValidation from '../../../resources/i18n/en/validation.json';
@@ -22,10 +21,12 @@ const resources = {
   },
 } as const;
 
+const fallbackLocale = (I18N_LOCALES[0] ?? 'en') as I18nLocale;
+
 void i18n.use(initReactI18next).init({
   resources,
   lng: getInitialLocale(),
-  fallbackLng: I18N_DEFAULT_LANG,
+  fallbackLng: fallbackLocale,
   interpolation: {
     escapeValue: false,
   },

package/templates/module-presets/i18n/packages/i18n-contracts/package.json

@@ -7,7 +7,9 @@
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "check:keys": "node scripts/check-keys.mjs"
+    "i18n:sync": "node scripts/i18n-sync.mjs",
+    "i18n:check": "node scripts/i18n-check.mjs",
+    "i18n:types": "node scripts/i18n-types.mjs"
   },
   "devDependencies": {
     "@types/node": "^22.10.7",

package/templates/module-presets/i18n/packages/i18n-contracts/scripts/i18n-check.mjs

@@ -0,0 +1,112 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  fail,
+  flattenKeys,
+  getStructure,
+  readGeneratedContracts,
+  readJsonFile,
+  resourcesRoot,
+  sorted,
+  success,
+  warn,
+} from './i18n-shared.mjs';
+
+function diff(expected, actual) {
+  return {
+    missing: expected.filter((item) => !actual.includes(item)),
+    extra: actual.filter((item) => !expected.includes(item)),
+  };
+}
+
+function main() {
+  const issues = [];
+  const { locales, namespaces, fallbackLocale } = getStructure();
+  const generated = readGeneratedContracts();
+
+  const localeDiff = diff(locales, generated.locales);
+  for (const item of localeDiff.missing) {
+    issues.push(`[contracts] missing locale: ${item}`);
+  }
+  for (const item of localeDiff.extra) {
+    issues.push(`[contracts] extra locale: ${item}`);
+  }
+
+  const namespaceDiff = diff(namespaces, generated.namespaces);
+  for (const item of namespaceDiff.missing) {
+    issues.push(`[contracts] missing namespace: ${item}`);
+  }
+  for (const item of namespaceDiff.extra) {
+    issues.push(`[contracts] extra namespace: ${item}`);
+  }
+
+  const fallbackKeyMap = {};
+  for (const namespace of namespaces) {
+    const fallbackPath = path.join(resourcesRoot, fallbackLocale, `${namespace}.json`);
+    try {
+      const fallbackJson = readJsonFile(fallbackPath);
+      fallbackKeyMap[namespace] = sorted(flattenKeys(fallbackJson));
+    } catch (error) {
+      issues.push(
+        `[${fallbackLocale}] invalid JSON in ${namespace}.json: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  for (const locale of locales) {
+    const localeDir = path.join(resourcesRoot, locale);
+    const localeNamespaces = fs
+      .readdirSync(localeDir, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+      .map((entry) => entry.name.slice(0, -5));
+
+    const localeNamespaceDiff = diff(namespaces, sorted(localeNamespaces));
+    for (const missingNamespace of localeNamespaceDiff.missing) {
+      issues.push(`[${locale}] missing namespace file: ${missingNamespace}.json`);
+    }
+    for (const extraNamespace of localeNamespaceDiff.extra) {
+      issues.push(`[${locale}] extra namespace file: ${extraNamespace}.json`);
+    }
+
+    for (const namespace of namespaces) {
+      const localePath = path.join(localeDir, `${namespace}.json`);
+      if (!fs.existsSync(localePath)) {
+        continue;
+      }
+
+      let localeJson;
+      try {
+        localeJson = readJsonFile(localePath);
+      } catch (error) {
+        issues.push(
+          `[${locale}] invalid JSON in ${namespace}.json: ${error instanceof Error ? error.message : String(error)}`,
+        );
+        continue;
+      }
+
+      const localeKeys = sorted(flattenKeys(localeJson));
+      const expectedKeys = fallbackKeyMap[namespace] ?? [];
+      const keyDiff = diff(expectedKeys, localeKeys);
+
+      for (const key of keyDiff.missing) {
+        issues.push(`[${locale}] missing key in ${namespace}.json: ${key}`);
+      }
+      for (const key of keyDiff.extra) {
+        issues.push(`[${locale}] extra key in ${namespace}.json: ${key}`);
+      }
+    }
+  }
+
+  if (issues.length > 0) {
+    fail('i18n check failed.');
+    for (const issue of issues) {
+      fail(`- ${issue}`);
+    }
+    warn('Run `pnpm i18n:sync` if locales/namespaces changed.');
+    process.exit(1);
+  }
+
+  success('i18n check passed.');
+}
+
+main();

package/templates/module-presets/i18n/packages/i18n-contracts/scripts/i18n-shared.mjs

@@ -0,0 +1,162 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const packageRoot = path.resolve(__dirname, '..');
+export const projectRoot = path.resolve(packageRoot, '..', '..');
+export const resourcesRoot = path.join(projectRoot, 'resources', 'i18n');
+export const generatedPath = path.join(packageRoot, 'src', 'generated.ts');
+export const generatedTypesPath = path.join(packageRoot, 'src', 'generated-keys.d.ts');
+
+const ANSI = {
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  green: '\x1b[32m',
+  cyan: '\x1b[36m',
+  reset: '\x1b[0m',
+};
+
+function paint(color, text) {
+  return `${ANSI[color]}${text}${ANSI.reset}`;
+}
+
+export function info(text) {
+  console.log(paint('cyan', text));
+}
+
+export function success(text) {
+  console.log(paint('green', text));
+}
+
+export function warn(text) {
+  console.log(paint('yellow', text));
+}
+
+export function fail(text) {
+  console.error(paint('red', text));
+}
+
+export function sorted(values) {
+  return [...values].sort((a, b) => a.localeCompare(b));
+}
+
+export function flattenKeys(value, prefix = '') {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return prefix ? [prefix] : [];
+  }
+
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    return prefix ? [prefix] : [];
+  }
+
+  const keys = [];
+  for (const [key, nested] of entries) {
+    const nextPrefix = prefix ? `${prefix}.${key}` : key;
+    keys.push(...flattenKeys(nested, nextPrefix));
+  }
+  return keys;
+}
+
+export function readJsonFile(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+export function ensureResourcesRoot() {
+  if (!fs.existsSync(resourcesRoot)) {
+    throw new Error(`Missing resources folder: ${resourcesRoot}`);
+  }
+}
+
+export function listLocales() {
+  ensureResourcesRoot();
+  const locales = fs
+    .readdirSync(resourcesRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+  return sorted(locales);
+}
+
+export function resolveFallbackLocale(locales) {
+  const requested = process.env.I18N_FALLBACK_LANG?.trim();
+  if (requested && locales.includes(requested)) {
+    return requested;
+  }
+  if (locales.includes('en')) {
+    return 'en';
+  }
+  return locales[0];
+}
+
+export function listNamespaceFiles(locale) {
+  const localeDir = path.join(resourcesRoot, locale);
+  if (!fs.existsSync(localeDir)) {
+    return [];
+  }
+  const namespaces = fs
+    .readdirSync(localeDir, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+    .map((entry) => entry.name.slice(0, -5));
+  return sorted(namespaces);
+}
+
+export function getStructure() {
+  const locales = listLocales();
+  if (locales.length === 0) {
+    throw new Error(`No locales found in ${resourcesRoot}`);
+  }
+
+  const fallbackLocale = resolveFallbackLocale(locales);
+  const namespaces = listNamespaceFiles(fallbackLocale);
+  if (namespaces.length === 0) {
+    throw new Error(`No namespaces found for fallback locale "${fallbackLocale}"`);
+  }
+
+  return { locales, namespaces, fallbackLocale };
+}
+
+export function renderGeneratedContracts({ locales, namespaces }) {
+  return `/* AUTO-GENERATED BY \`pnpm i18n:sync\`. DO NOT EDIT MANUALLY. */
+
+export const I18N_LOCALES = ${JSON.stringify(locales)} as const;
+export const I18N_NAMESPACES = ${JSON.stringify(namespaces)} as const;
+
+export type I18nLocale = (typeof I18N_LOCALES)[number];
+export type I18nNamespace = (typeof I18N_NAMESPACES)[number];
+`;
+}
+
+export function parseGeneratedArray(source, constName) {
+  const regex = new RegExp(`export const ${constName} = (\\[[^\\n]+\\]) as const;`);
+  const match = source.match(regex);
+  if (!match) {
+    throw new Error(`Could not read ${constName} from generated.ts`);
+  }
+  return JSON.parse(match[1]);
+}
+
+export function readGeneratedContracts() {
+  if (!fs.existsSync(generatedPath)) {
+    throw new Error(`Missing generated contracts file: ${generatedPath}`);
+  }
+  const source = fs.readFileSync(generatedPath, 'utf8');
+  return {
+    locales: parseGeneratedArray(source, 'I18N_LOCALES'),
+    namespaces: parseGeneratedArray(source, 'I18N_NAMESPACES'),
+  };
+}
+
+export function writeTextFile(filePath, content) {
+  fs.writeFileSync(filePath, `${content.trimEnd()}\n`, 'utf8');
+}
+
+export function readLocaleNamespaceJson(locale, namespace) {
+  const filePath = path.join(resourcesRoot, locale, `${namespace}.json`);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Missing file: ${path.relative(projectRoot, filePath)}`);
+  }
+  return readJsonFile(filePath);
+}

package/templates/module-presets/i18n/packages/i18n-contracts/scripts/i18n-sync.mjs

@@ -0,0 +1,19 @@
+import {
+  generatedPath,
+  getStructure,
+  info,
+  renderGeneratedContracts,
+  success,
+  writeTextFile,
+} from './i18n-shared.mjs';
+
+function main() {
+  const { locales, namespaces, fallbackLocale } = getStructure();
+  writeTextFile(generatedPath, renderGeneratedContracts({ locales, namespaces }));
+  success('i18n contracts synced.');
+  info(`- fallback locale: ${fallbackLocale}`);
+  info(`- locales: ${locales.join(', ')}`);
+  info(`- namespaces: ${namespaces.join(', ')}`);
+}
+
+main();

package/templates/module-presets/i18n/packages/i18n-contracts/scripts/i18n-types.mjs

@@ -0,0 +1,42 @@
+import {
+  flattenKeys,
+  generatedTypesPath,
+  getStructure,
+  readLocaleNamespaceJson,
+  sorted,
+  success,
+  writeTextFile,
+} from './i18n-shared.mjs';
+
+function escapeQuote(value) {
+  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function main() {
+  const { fallbackLocale, namespaces } = getStructure();
+  const keys = [];
+
+  for (const namespace of namespaces) {
+    const payload = readLocaleNamespaceJson(fallbackLocale, namespace);
+    const flattened = sorted(flattenKeys(payload));
+    for (const key of flattened) {
+      keys.push(`${namespace}.${key}`);
+    }
+  }
+
+  const union =
+    keys.length > 0
+      ? keys.map((key) => `  | "${escapeQuote(key)}"`).join('\n')
+      : '  | never';
+
+  const content = `/* AUTO-GENERATED BY \`pnpm i18n:types\`. DO NOT EDIT MANUALLY. */
+
+export type I18nTranslationKey =
+${union};
+`;
+
+  writeTextFile(generatedTypesPath, content);
+  success(`i18n types generated (${keys.length} keys).`);
+}
+
+main();

package/templates/module-presets/i18n/packages/i18n-contracts/src/generated-keys.d.ts

@@ -0,0 +1,11 @@
+/* AUTO-GENERATED BY `pnpm i18n:types`. DO NOT EDIT MANUALLY. */
+
+export type I18nTranslationKey =
+  | "common.checkApiHealth"
+  | "common.language"
+  | "common.languages.english"
+  | "common.languages.ukrainian"
+  | "common.ok"
+  | "errors.accessDenied"
+  | "errors.notFound"
+  | "validation.required";

package/templates/module-presets/i18n/packages/i18n-contracts/src/generated.ts

@@ -0,0 +1,7 @@
+/* AUTO-GENERATED BY `pnpm i18n:sync`. DO NOT EDIT MANUALLY. */
+
+export const I18N_LOCALES = ["en", "uk"] as const;
+export const I18N_NAMESPACES = ["common", "errors", "validation"] as const;
+
+export type I18nLocale = (typeof I18N_LOCALES)[number];
+export type I18nNamespace = (typeof I18N_NAMESPACES)[number];

package/templates/module-presets/i18n/packages/i18n-contracts/src/index.ts

@@ -1,9 +1,8 @@
-export const I18N_LOCALES = ['en', 'uk'] as const;
-export const I18N_NAMESPACES = ['common', 'errors', 'validation'] as const;
-
-export type I18nLocale = (typeof I18N_LOCALES)[number];
-export type I18nNamespace = (typeof I18N_NAMESPACES)[number];
-
-export const I18N_DEFAULT_LANG: I18nLocale = 'en';
-export const I18N_FALLBACK_LANG: I18nLocale = 'en';
+export {
+  I18N_LOCALES,
+  I18N_NAMESPACES,
+  type I18nLocale,
+  type I18nNamespace,
+} from './generated';
+export type { I18nTranslationKey } from './generated-keys';
 export const LANG_QUERY_PARAM = 'lang';

package/templates/module-presets/i18n/packages/i18n-web/src/index.ts

@@ -1,11 +1,11 @@
 import {
-  I18N_DEFAULT_LANG,
   I18N_LOCALES,
   LANG_QUERY_PARAM,
   type I18nLocale,
 } from '@forgeon/i18n-contracts';
 
 const LOCALE_STORAGE_KEY = 'forgeon.locale';
+const DEFAULT_LOCALE = (I18N_LOCALES[0] ?? 'en') as I18nLocale;
 
 type StorageLike = {
   getItem: (key: string) => string | null;
@@ -35,7 +35,7 @@ export function getInitialLocale(): I18nLocale {
   if (stored && isSupportedLocale(stored)) {
     return stored;
   }
-  return I18N_DEFAULT_LANG;
+  return DEFAULT_LOCALE;
 }
 
 export function persistLocale(locale: I18nLocale): void {

package/templates/module-presets/i18n/packages/i18n-contracts/scripts/check-keys.mjs

@@ -1,97 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const projectRoot = path.resolve(__dirname, '..', '..', '..');
-const resourcesRoot = path.join(projectRoot, 'resources', 'i18n');
-const baseLocale = 'en';
-
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-}
-
-function flattenKeys(value, prefix = '') {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-    return prefix ? [prefix] : [];
-  }
-
-  const entries = Object.entries(value);
-  if (entries.length === 0) {
-    return prefix ? [prefix] : [];
-  }
-
-  const result = [];
-  for (const [key, nested] of entries) {
-    const nextPrefix = prefix ? `${prefix}.${key}` : key;
-    result.push(...flattenKeys(nested, nextPrefix));
-  }
-  return result;
-}
-
-function sorted(array) {
-  return [...array].sort((a, b) => a.localeCompare(b));
-}
-
-function main() {
-  if (!fs.existsSync(resourcesRoot)) {
-    console.error(`Missing resources folder: ${resourcesRoot}`);
-    process.exit(1);
-  }
-
-  const localeDirs = fs
-    .readdirSync(resourcesRoot, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => entry.name);
-
-  if (!localeDirs.includes(baseLocale)) {
-    console.error(`Missing base locale "${baseLocale}" in ${resourcesRoot}`);
-    process.exit(1);
-  }
-
-  const baseLocaleDir = path.join(resourcesRoot, baseLocale);
-  const baseFiles = fs
-    .readdirSync(baseLocaleDir)
-    .filter((name) => name.endsWith('.json'));
-
-  const errors = [];
-
-  for (const locale of localeDirs) {
-    const localeDir = path.join(resourcesRoot, locale);
-    for (const fileName of baseFiles) {
-      const baseFilePath = path.join(baseLocaleDir, fileName);
-      const localeFilePath = path.join(localeDir, fileName);
-
-      if (!fs.existsSync(localeFilePath)) {
-        errors.push(`[${locale}] missing file: ${fileName}`);
-        continue;
-      }
-
-      const baseKeys = sorted(flattenKeys(readJson(baseFilePath)));
-      const localeKeys = sorted(flattenKeys(readJson(localeFilePath)));
-
-      const missingKeys = baseKeys.filter((key) => !localeKeys.includes(key));
-      const extraKeys = localeKeys.filter((key) => !baseKeys.includes(key));
-
-      for (const key of missingKeys) {
-        errors.push(`[${locale}] missing key in ${fileName}: ${key}`);
-      }
-      for (const key of extraKeys) {
-        errors.push(`[${locale}] extra key in ${fileName}: ${key}`);
-      }
-    }
-  }
-
-  if (errors.length > 0) {
-    console.error('i18n key check failed:');
-    for (const error of errors) {
-      console.error(`- ${error}`);
-    }
-    process.exit(1);
-  }
-
-  console.log('i18n key check passed.');
-}
-
-main();