feat(i18n): implement core infrastructure and CLI entrypoint

Author: jethac

package-lock.json

@@ -4,6 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+// Initialize i18n before any React components
+import './i18n/index.js';
+
 import React from 'react';
 import { render } from 'ink';
 import { AppContainer } from './ui/AppContainer.js';

packages/cli/src/gemini.tsx

@@ -7,6 +7,7 @@
 import i18n, { t } from 'i18next';
 import { initReactI18next } from 'react-i18next';
 import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -23,21 +24,116 @@ async function loadTranslationFile(
     const filePath = path.join(__dirname, 'locales', lang, `${namespace}.json`);
     const content = await fs.readFile(filePath, 'utf8');
     return JSON.parse(content) as Record<string, unknown>;
-  } catch (error) {
-    console.warn(
-      `Failed to load translation file for ${lang}/${namespace}:`,
-      error,
-    );
+  } catch (_error) {
+    // Silently fail if file doesn't exist - i18next handles missing keys
     return {};
   }
 }
 
-// Phase 1: Only English locale, core namespaces
-const languages = ['en'];
 const namespaces = ['common', 'help', 'dialogs'];
+const localesDir = path.join(__dirname, 'locales');
 
-// Async resource loading
-async function loadResources() {
+// Language display names for settings UI
+const LANGUAGE_LABELS: Record<string, string> = {
+  en: 'English',
+  ja: '日本語',
+  // Add more language labels here as locales are added
+};
+
+/**
+ * Synchronously scan the locales directory to find available language packs.
+ * This runs at module load time so the schema can access the options.
+ */
+function detectAvailableLanguagesSync(): string[] {
+  try {
+    const entries = fsSync.readdirSync(localesDir, { withFileTypes: true });
+    const langs = entries
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .filter((name) => !name.startsWith('.')); // Exclude hidden directories
+
+    // Ensure 'en' is always first (default/fallback language)
+    if (langs.includes('en')) {
+      return ['en', ...langs.filter((l) => l !== 'en')];
+    }
+    return langs.length > 0 ? langs : ['en'];
+  } catch {
+    // If we can't read the directory, fall back to English only
+    return ['en'];
+  }
+}
+
+// Detect available languages synchronously at module load
+const availableLanguages: string[] = detectAvailableLanguagesSync();
+
+/**
+ * Get the list of available languages (detected from locale folders).
+ */
+export function getAvailableLanguages(): string[] {
+  return [...availableLanguages];
+}
+
+/**
+ * Check if a language code is available (has a locale pack).
+ */
+export function isLanguageAvailable(lang: string): boolean {
+  return availableLanguages.includes(lang);
+}
+
+/**
+ * Get language options formatted for the settings schema.
+ * Returns an array with 'auto' option followed by available languages.
+ */
+export function getLanguageOptions(): Array<{ value: string; label: string }> {
+  const options: Array<{ value: string; label: string }> = [
+    { value: 'auto', label: 'Auto' },
+  ];
+
+  for (const lang of availableLanguages) {
+    options.push({
+      value: lang,
+      label: LANGUAGE_LABELS[lang] ?? lang.toUpperCase(),
+    });
+  }
+
+  return options;
+}
+
+/**
+ * Detect the system language from environment variables or Intl API.
+ * Priority: GEMINI_LANG > LANG > Intl > 'en' (fallback)
+ * Only returns languages that have available locale packs.
+ */
+function getSystemLanguage(): string {
+  const checkLang = (locale: string | undefined): string | null => {
+    if (!locale) return null;
+    const lang = locale.split(/[-_]/)[0]?.toLowerCase();
+    return lang && availableLanguages.includes(lang) ? lang : null;
+  };
+
+  // 1. Check GEMINI_LANG environment variable (explicit override)
+  const fromGeminiLang = checkLang(process.env['GEMINI_LANG']);
+  if (fromGeminiLang) return fromGeminiLang;
+
+  // 2. Check LANG environment variable (Unix-style locale)
+  const fromLangEnv = checkLang(process.env['LANG']);
+  if (fromLangEnv) return fromLangEnv;
+
+  // 3. Check Intl API (browser/Node.js locale detection)
+  try {
+    const intlLocale = Intl.DateTimeFormat().resolvedOptions().locale;
+    const fromIntl = checkLang(intlLocale);
+    if (fromIntl) return fromIntl;
+  } catch {
+    // Intl may not be available in some environments
+  }
+
+  // 4. Fallback to English
+  return 'en';
+}
+
+// Async resource loading - only loads for available languages
+async function loadResources(languages: string[]) {
   const resources: Record<string, Record<string, Record<string, unknown>>> = {};
 
   for (const lang of languages) {
@@ -58,12 +154,16 @@ async function loadResources() {
 
 // Initialize i18next with async resource loading
 async function initializeI18n() {
-  const resources = await loadResources();
+  // Load resources only for available languages (detected at module load)
+  const resources = await loadResources(availableLanguages);
+
+  // Determine the language to use (auto-detect or fallback)
+  const detectedLanguage = getSystemLanguage();
 
   // eslint-disable-next-line import/no-named-as-default-member
   await i18n.use(initReactI18next).init({
     resources,
-    lng: 'en',
+    lng: detectedLanguage,
     fallbackLng: 'en',
 
     interpolation: {