@lastbrain/app 2.0.15 → 2.0.21

package/dist/scripts/module-build.js

@@ -10,6 +10,19 @@ const _monorepoRoot = projectRoot.includes("/apps/")
 const appDirectory = path.join(projectRoot, "app");
 // Mode debug activé via --debug
 const isDebugMode = process.argv.includes("--debug");
+// Helper pour écrire (générer ou mettre à jour) un fichier de scaffold
+function ensureDirectory(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function writeScaffoldFile(targetPath, content, label) {
+    const existed = fs.existsSync(targetPath);
+    ensureDirectory(path.dirname(targetPath));
+    fs.writeFileSync(targetPath, content, "utf-8");
+    if (isDebugMode) {
+        const status = existed ? "♻️ Updated" : "✅ Generated";
+        console.log(`${status} ${label}: ${targetPath}`);
+    }
+}
 // Créer un require dans le contexte de l'application pour résoudre les modules installés dans l'app
 const projectRequire = createRequire(path.join(projectRoot, "package.json"));
 // Charger les modules depuis modules.json
@@ -70,10 +83,10 @@ async function loadModuleConfigs() {
     return moduleConfigs;
 }
 const sectionDirectoryMap = {
-    public: ["(public)"],
-    auth: ["auth"],
-    admin: ["admin"],
-    user: ["auth", "user"],
+    public: ["[lang]", "(public)"],
+    auth: ["[lang]", "auth"],
+    admin: ["[lang]", "admin"],
+    user: ["[lang]", "auth", "user"],
 };
 const sectionLayoutMap = {
     auth: "AuthLayout",
@@ -87,9 +100,6 @@ const navigation = {
     admin: [],
 };
 const userMenu = [];
-function ensureDirectory(dir) {
-    fs.mkdirSync(dir, { recursive: true });
-}
 function ensureSectionLayout(sectionPath) {
     const sectionDir = path.join(appDirectory, ...sectionPath);
     const sectionKey = sectionPath[0];
@@ -101,16 +111,13 @@ function ensureSectionLayout(sectionPath) {
     const layoutName = sectionLayoutMap[sectionKey];
     if (layoutName) {
         const layoutPath = path.join(sectionDir, "layout.tsx");
-        if (!fs.existsSync(layoutPath)) {
-            const layoutContent = `import { ${layoutName} } from "@lastbrain/app";
+        const layoutContent = `import { ${layoutName} } from "@lastbrain/app";
+import type React from "react";
 
 export default function SectionLayout({ children }: { children: React.ReactNode }) {
   return <${layoutName}>{children}</${layoutName}>;
-}
-`;
-            fs.writeFileSync(layoutPath, layoutContent);
-            console.log(`📐 Generated section layout: ${layoutPath}`);
-        }
+}`;
+        writeScaffoldFile(layoutPath, layoutContent, `${sectionKey} layout`);
     }
     generatedSections.add(sectionKey);
 }
@@ -165,7 +172,9 @@ function buildPage(moduleConfig, page) {
         : "Root";
     const wrapperName = `${page.componentExport}${wrapperSuffix}Route`;
     // Vérifier si la route a des paramètres dynamiques (segments avec [])
-    const hasDynamicParams = segments.some((seg) => seg.startsWith("[") && seg.endsWith("]"));
+    // Inclure les segments du sectionPath (ex: [lang]) ET les segments du module
+    const allSegments = [...sectionPath, ...segments];
+    const hasDynamicParams = allSegments.some((seg) => seg.startsWith("[") && seg.endsWith("]"));
     // Pour les pages publiques (signin, signup, etc.), utiliser dynamic import sans SSR
     // pour éviter les erreurs d'hydratation avec les IDs HeroUI/React Aria
     const isPublicAuthPage = page.section === "public" &&
@@ -193,7 +202,7 @@ interface UserPageProps { params: Promise<{ id: string }> }
 async function getModuleUserTabs() {
   try {
     // Depuis /app/admin/auth/users/[id]/ vers /apps/test-01/config/user-tabs
-    const { moduleUserTabs } = await import("../../../../../config/user-tabs");
+    const { moduleUserTabs } = await import("../../../../../../config/user-tabs");
     return moduleUserTabs || [];
   } catch (e) {
     console.warn("[user-detail-wrapper] erreur chargement user-tabs", e);
@@ -236,11 +245,33 @@ export default function ${wrapperName}${hasDynamicParams ? "(props: Record<strin
 `;
     }
     else {
+        // Déterminer le chemin d'import
+        const importPath = page.entryPoint
+            ? `${moduleConfig.moduleName}/${page.entryPoint}`
+            : moduleConfig.moduleName;
+        // Extraire les noms des paramètres dynamiques pour le typage
+        // Inclure les segments du sectionPath (ex: [lang]) ET les segments du module
+        const allSegments = [...sectionPath, ...segments];
+        const dynamicParamNames = allSegments
+            .filter((seg) => seg.startsWith("[") && seg.endsWith("]"))
+            .map((seg) => seg.slice(1, -1)); // Enlève les []
+        // Générer le type des params si nécessaire
+        const paramsType = dynamicParamNames.length > 0
+            ? `{ ${dynamicParamNames.map((name) => `${name}: string`).join("; ")} }`
+            : "";
+        const propsSignature = hasDynamicParams && paramsType
+            ? `({\n  params,\n}: {\n  params: Promise<${paramsType}>;\n})`
+            : "()";
+        // Les composants utilisent useParams() en interne, on ne passe jamais params en props
+        // On fait juste l'unwrap pour Next.js 15 si des params existent
+        const awaitParams = hasDynamicParams
+            ? "await params; // Unwrap params for Next.js 15\n  "
+            : "";
         content = `// GENERATED BY LASTBRAIN MODULE BUILD
-import { ${page.componentExport} } from "${moduleConfig.moduleName}";
-
-export default function ${wrapperName}${hasDynamicParams ? "(props: Record<string, unknown>)" : "()"} {
-  return <${page.componentExport} ${hasDynamicParams ? "{...props}" : ""} />;
+import { ${page.componentExport} } from "${importPath}";
+${page.metadataExport ? `\nexport { ${page.metadataExport} as generateMetadata } from "${importPath}";\n` : ""}
+export default ${hasDynamicParams ? "async " : ""}function ${wrapperName}${propsSignature} {
+  ${awaitParams}return <${page.componentExport} />;
 }
 `;
     }
@@ -341,7 +372,7 @@ function generateMenuConfig(moduleConfigs) {
     // Fonction pour préparer les menus avec les composants
     const prepareMenusForExport = (menus) => {
         return menus.map((menu) => {
-            const { moduleName, __componentRef, ...cleanMenu } = menu;
+            const { moduleName: _moduleName, __componentRef, ...cleanMenu } = menu;
             if (__componentRef) {
                 // Retourner une référence au composant au lieu de la sérialiser
                 return `{ ...${JSON.stringify(cleanMenu)}, component: ${__componentRef} }`;
@@ -550,10 +581,12 @@ function buildGroupedApi(apis, routePath) {
     const exportsBySource = new Map();
     apis.forEach(({ moduleConfig, api }) => {
         const handler = `${moduleConfig.moduleName}/${api.entryPoint}`;
-        if (!exportsBySource.has(handler)) {
-            exportsBySource.set(handler, []);
+        const currentExports = exportsBySource.get(handler);
+        if (currentExports) {
+            currentExports.push(api.handlerExport);
+            return;
         }
-        exportsBySource.get(handler).push(api.handlerExport);
+        exportsBySource.set(handler, [api.handlerExport]);
     });
     // Générer les exports - un export statement par source
     const exportStatements = [];
@@ -658,7 +691,7 @@ function cleanGeneratedFiles() {
         }
     };
     // Nettoyer les dossiers de sections
-    const sectionsToClean = ["(public)", "auth", "admin", "api"];
+    const sectionsToClean = ["(public)", "auth", "admin", "api", "[lang]"];
     sectionsToClean.forEach((section) => {
         const sectionPath = path.join(appDirectory, section);
         if (fs.existsSync(sectionPath)) {
@@ -680,15 +713,55 @@ function cleanGeneratedFiles() {
         console.log("🧹 Cleanup completed");
     }
 }
+/**
+ * Supprime les anciennes routes sans [lang] et les layouts générés
+ */
+function cleanOldRoutesWithoutLang() {
+    const generatedComment = "// GENERATED BY LASTBRAIN MODULE BUILD";
+    // Supprimer les anciens dossiers de sections sans [lang]
+    const oldSections = ["(public)", "auth", "admin"];
+    oldSections.forEach((section) => {
+        const sectionPath = path.join(appDirectory, section);
+        if (fs.existsSync(sectionPath)) {
+            try {
+                // Supprimer récursivement tout le dossier
+                fs.rmSync(sectionPath, { recursive: true, force: true });
+                if (isDebugMode) {
+                    console.log(`🗑️  Removed old section without [lang]: ${section}`);
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️  Could not remove ${section}:`, error);
+            }
+        }
+    });
+    // Supprimer les layouts générés dans [lang]
+    const langLayoutsToRemove = [
+        path.join(appDirectory, "[lang]", "layout.tsx"),
+        path.join(appDirectory, "[lang]", "auth", "layout.tsx"),
+        path.join(appDirectory, "[lang]", "admin", "layout.tsx"),
+    ];
+    langLayoutsToRemove.forEach((layoutPath) => {
+        if (fs.existsSync(layoutPath)) {
+            try {
+                const content = fs.readFileSync(layoutPath, "utf-8");
+                // Supprimer si c'est un fichier généré
+                if (content.includes(generatedComment) ||
+                    content.includes("AppProviders")) {
+                    fs.unlinkSync(layoutPath);
+                    if (isDebugMode) {
+                        console.log(`🗑️  Removed generated layout: ${layoutPath}`);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️  Could not remove layout ${layoutPath}:`, error);
+            }
+        }
+    });
+}
 function generateAppAside() {
     const targetPath = path.join(appDirectory, "components", "AppAside.tsx");
-    // Ne pas écraser si le fichier existe déjà
-    if (fs.existsSync(targetPath)) {
-        if (isDebugMode) {
-            console.log(`⏭️ AppAside already exists, skipping: ${targetPath}`);
-        }
-        return;
-    }
     const templateContent = `"use client";
 
 import { AppAside as UIAppAside } from "@lastbrain/app";
@@ -713,86 +786,236 @@ export function AppAside({ className = "", isVisible = true }: AppAsideProps) {
   );
 }`;
     try {
-        ensureDirectory(path.dirname(targetPath));
-        fs.writeFileSync(targetPath, templateContent, "utf-8");
-        if (isDebugMode) {
-            console.log(`✅ Generated AppAside component: ${targetPath}`);
-        }
+        writeScaffoldFile(targetPath, templateContent, "AppAside component");
     }
     catch (error) {
         console.error(`❌ Error generating AppAside component: ${error}`);
     }
 }
 function generateLayouts() {
-    // Générer layout auth avec sidebar
-    const authLayoutPath = path.join(appDirectory, "auth", "layout.tsx");
-    if (!fs.existsSync(authLayoutPath)) {
-        const authLayoutContent = `import { AuthLayoutWithSidebar } from "@lastbrain/app";
+    // Générer ClientLayout wrapper client
+    const clientLayoutPath = path.join(appDirectory, "components", "ClientLayout.tsx");
+    const clientLayoutContent = `"use client";
+
+import { HeroUIProvider } from "@heroui/system";
+import { ThemeProvider } from "next-themes";
+import { AppProviders } from "./AppProviders";
+import { AppHeader } from "./AppHeader";
+import type { ReactNode } from "react";
+import { useLocalizedRouter, type Language } from "@lastbrain/core";
+
+
+export function ClientLayout({
+  children,
+  lang = "fr",
+  translations = {},
+}: {
+  children: ReactNode;
+  lang?: Language;
+  translations?: Record<string, string>;
+}) {
+  const router = useLocalizedRouter();
+
+  return (
+    <HeroUIProvider navigate={router.push}>
+      <ThemeProvider
+        attribute="class"
+        defaultTheme="dark"
+        enableSystem={false}
+        storageKey="lastbrain-theme"
+      >
+        <AppProviders lang={lang} translations={translations}>
+          <AppHeader />
+          <div className="min-h-screen text-foreground bg-background">
+            {children}
+          </div>
+        </AppProviders>
+      </ThemeProvider>
+    </HeroUIProvider>
+  );
+}`;
+    try {
+        writeScaffoldFile(clientLayoutPath, clientLayoutContent, "ClientLayout component");
+    }
+    catch (error) {
+        console.error(`❌ Error generating ClientLayout component: ${error}`);
+    }
+    // Générer AppProviders wrapper client
+    const appProvidersPath = path.join(appDirectory, "components", "AppProviders.tsx");
+    const appProvidersContent = `"use client";
+
+import { AppProviders as BaseAppProviders } from "@lastbrain/app";
+import { realtimeConfig } from "../../config/realtime";
+import type { ReactNode } from "react";
+import type { Language } from "@lastbrain/core";
+
+export function AppProviders({
+  children,
+  lang = "fr",
+  translations = {},
+}: {
+  children: ReactNode;
+  lang?: Language;
+  translations?: Record<string, string>;
+}) {
+  return (
+    <BaseAppProviders
+      realtimeConfig={realtimeConfig}
+      lang={lang}
+      translations={translations}
+    >
+      {children}
+    </BaseAppProviders>
+  );
+}`;
+    try {
+        writeScaffoldFile(appProvidersPath, appProvidersContent, "AppProviders component");
+    }
+    catch (error) {
+        console.error(`❌ Error generating AppProviders component: ${error}`);
+    }
+    // Générer AppHeader component
+    const appHeaderPath = path.join(appDirectory, "components", "AppHeader.tsx");
+    const appHeaderContent = `"use client";
+
+import { Header } from "@lastbrain/ui";
+import { LanguageSwitcher } from "@lastbrain/app";
 import { menuConfig } from "../../config/menu";
 
-export default function SectionLayout({
+export function AppHeader() {
+  return (
+    <Header
+      menuConfig={menuConfig}
+      languageSwitcher={<LanguageSwitcher variant="minimal" />}
+    />
+  );
+}`;
+    try {
+        writeScaffoldFile(appHeaderPath, appHeaderContent, "AppHeader component");
+    }
+    catch (error) {
+        console.error(`❌ Error generating AppHeader component: ${error}`);
+    }
+    // Générer layout [lang] pour la gestion i18n
+    const langLayoutPath = path.join(appDirectory, "[lang]", "layout.tsx");
+    if (!fs.existsSync(langLayoutPath)) {
+        const langLayoutContent = `import { loadTranslations } from "@lastbrain/app/i18n/server-lang";
+import { ClientLayout } from "../../components/ClientLayout";
+
+export default async function LangLayout({
   children,
+  params,
 }: {
   children: React.ReactNode;
+  params: Promise<{ lang: string }>;
 }) {
+  const { lang } = await params;
+  const validLang = lang === "en" || lang === "fr" ? lang : "fr";
+  
+  // Charger les traductions pour cette langue
+  const translations = await loadTranslations(validLang);
+  
   return (
-    <AuthLayoutWithSidebar menuConfig={menuConfig}>
-      {children}
-    </AuthLayoutWithSidebar>
+    <ClientLayout lang={validLang} translations={translations}>
+      <div className="min-h-screen pt-16">
+        {children}
+      </div>
+    </ClientLayout>
   );
 }`;
         try {
-            ensureDirectory(path.dirname(authLayoutPath));
-            fs.writeFileSync(authLayoutPath, authLayoutContent, "utf-8");
+            ensureDirectory(path.dirname(langLayoutPath));
+            fs.writeFileSync(langLayoutPath, langLayoutContent, "utf-8");
             if (isDebugMode) {
-                console.log(`✅ Generated auth layout with sidebar: ${authLayoutPath}`);
+                console.log(`✅ Generated [lang] layout: ${langLayoutPath}`);
             }
         }
         catch (error) {
-            console.error(`❌ Error generating auth layout: ${error}`);
+            console.error(`❌ Error generating [lang] layout: ${error}`);
         }
     }
     else if (isDebugMode) {
-        console.log(`⏭️ Auth layout already exists, skipping: ${authLayoutPath}`);
+        console.log(`⏭️ [lang] layout already exists, skipping: ${langLayoutPath}`);
+    }
+    // Générer layout auth avec sidebar
+    const authLayoutPath = path.join(appDirectory, "[lang]", "auth", "layout.tsx");
+    const authLayoutContent = `"use client";
+
+import { AuthLayoutWithSidebar, langHref, useLanguage } from "@lastbrain/app";
+import { menuConfig as fullMenuConfig } from "../../../config/menu";
+
+export default function SectionLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  const { lang } = useLanguage();
+
+  // Transformer les paths du menu avec la langue
+  const menuConfig = {
+    ...fullMenuConfig,
+    auth: (fullMenuConfig.auth || []).map(item => ({
+      ...item,
+      path: item.path?.startsWith("/") && !item.path?.startsWith("/api/") 
+        ? langHref(item.path, lang)
+        : item.path
+    })),
+  };
+
+  return (
+    <AuthLayoutWithSidebar menuConfig={menuConfig}>
+      {children}
+    </AuthLayoutWithSidebar>
+  );
+}`;
+    try {
+        writeScaffoldFile(authLayoutPath, authLayoutContent, "auth layout with sidebar");
+    }
+    catch (error) {
+        console.error(`❌ Error generating auth layout: ${error}`);
     }
     // Générer layout admin avec sidebar
-    const adminLayoutPath = path.join(appDirectory, "admin", "layout.tsx");
-    if (!fs.existsSync(adminLayoutPath)) {
-        const adminLayoutContent = `import { AdminLayoutWithSidebar } from "@lastbrain/app";
-import { menuConfig } from "../../config/menu";
+    const adminLayoutPath = path.join(appDirectory, "[lang]", "admin", "layout.tsx");
+    const adminLayoutContent = `"use client";
+
+import { AdminLayoutWithSidebar, langHref, useLanguage } from "@lastbrain/app";
+import { menuConfig as fullMenuConfig } from "../../../config/menu";
 
 export default function AdminLayout({
   children,
 }: {
   children: React.ReactNode;
 }) {
+  const { lang } = useLanguage();
+
+  // Transformer les paths du menu avec la langue
+  const menuConfig = {
+    ...fullMenuConfig,
+    admin: (fullMenuConfig.admin || []).map(item => ({
+      ...item,
+      path: item.path?.startsWith("/") && !item.path?.startsWith("/api/") 
+        ? langHref(item.path, lang)
+        : item.path
+    })),
+  };
+
   return (
     <AdminLayoutWithSidebar menuConfig={menuConfig}>
       {children}
     </AdminLayoutWithSidebar>
   );
 }`;
-        try {
-            ensureDirectory(path.dirname(adminLayoutPath));
-            fs.writeFileSync(adminLayoutPath, adminLayoutContent, "utf-8");
-            if (isDebugMode) {
-                console.log(`✅ Generated admin layout with sidebar: ${adminLayoutPath}`);
-            }
-        }
-        catch (error) {
-            console.error(`❌ Error generating admin layout: ${error}`);
-        }
+    try {
+        writeScaffoldFile(adminLayoutPath, adminLayoutContent, "admin layout with sidebar");
     }
-    else if (isDebugMode) {
-        console.log(`⏭️ Admin layout already exists, skipping: ${adminLayoutPath}`);
+    catch (error) {
+        console.error(`❌ Error generating admin layout: ${error}`);
     }
 }
 async function generateRealtimeConfig(moduleConfigs) {
     try {
         // Extraire les configurations realtime des modules
-        const realtimeConfigs = moduleConfigs
-            .filter((config) => config.realtime)
-            .map((config) => config.realtime);
+        const realtimeConfigs = moduleConfigs.flatMap((config) => (config.realtime ? [config.realtime] : []));
         if (realtimeConfigs.length === 0) {
             console.log("⏭️ No realtime configuration found in modules");
             return;
@@ -842,8 +1065,7 @@ async function generateUserTabsConfig(moduleConfigs) {
     try {
         // Extraire les configurations user tabs des modules
         const userTabsConfigs = moduleConfigs
-            .filter((config) => config.userTabs && config.userTabs.length > 0)
-            .flatMap((config) => config.userTabs.map((tab) => ({
+            .flatMap((config) => (config.userTabs ?? []).map((tab) => ({
             ...tab,
             moduleName: config.moduleName,
         })))
@@ -898,9 +1120,7 @@ async function generateUserTabsConfig(moduleConfigs) {
 async function generateBucketsConfig(moduleConfigs) {
     try {
         // Extraire les configurations storage des modules
-        const allBuckets = moduleConfigs
-            .filter((config) => config.storage?.buckets && config.storage.buckets.length > 0)
-            .flatMap((config) => config.storage.buckets);
+        const allBuckets = moduleConfigs.flatMap((config) => config.storage?.buckets ?? []);
         if (allBuckets.length === 0) {
             console.log("⏭️ No storage buckets configuration found in modules");
             return;
@@ -1023,9 +1243,7 @@ export function isValidFileSize(bucketName: string, fileSize: number): boolean {
 async function generateStorageProxyApi(moduleConfigs) {
     try {
         // Extraire les configurations storage des modules
-        const allBuckets = moduleConfigs
-            .filter((config) => config.storage?.buckets && config.storage.buckets.length > 0)
-            .flatMap((config) => config.storage.buckets);
+        const allBuckets = moduleConfigs.flatMap((config) => config.storage?.buckets ?? []);
         if (allBuckets.length === 0) {
             console.log("⏭️ No storage buckets found, skipping proxy API generation");
             return;
@@ -1155,9 +1373,7 @@ export async function GET(
 async function generateFooterConfig(moduleConfigs) {
     try {
         // Extraire tous les liens footer des modules
-        const allFooterLinks = moduleConfigs
-            .filter((config) => config.footer && config.footer.length > 0)
-            .flatMap((config) => config.footer);
+        const allFooterLinks = moduleConfigs.flatMap((config) => config.footer ?? []);
         if (allFooterLinks.length === 0) {
             console.log("⏭️ No footer links found, skipping footer config generation");
             return;
@@ -1199,6 +1415,85 @@ export const footerConfig: FooterConfig = {
         console.error("❌ Error generating footer config:", error);
     }
 }
+/**
+ * Génère les fichiers i18n en concaténant les traductions des modules
+ */
+async function generateI18nFiles() {
+    const appI18nDir = path.join(projectRoot, "i18n");
+    const packagesDir = path.join(_monorepoRoot, "packages");
+    const translations = {
+        fr: {},
+        en: {},
+    };
+    try {
+        // Importer glob dynamiquement
+        const { glob } = await import("glob");
+        // Rechercher tous les fichiers i18n dans packages/**/src/i18n/*.json
+        const pattern = path.join(packagesDir, "**/src/i18n/*.json");
+        const files = await glob(pattern, {
+            ignore: ["**/node_modules/**", "**/dist/**"],
+        });
+        if (isDebugMode) {
+            console.log(`\n🔍 Found ${files.length} i18n files\n`);
+        }
+        for (const file of files) {
+            const fileName = path.basename(file, ".json");
+            const lang = fileName; // fr.json -> fr, en.json -> en
+            if (!translations[lang]) {
+                translations[lang] = {};
+            }
+            try {
+                const content = JSON.parse(fs.readFileSync(file, "utf-8"));
+                const moduleName = extractModuleNameFromPath(file);
+                if (isDebugMode) {
+                    console.log(`  ✓ ${moduleName} (${lang})`);
+                }
+                // Préfixer uniquement si la clé n'est pas déjà namespacée (avec ou sans suffixe -pro)
+                const moduleNamespace = moduleName.replace(/-pro$/, "");
+                for (const [key, value] of Object.entries(content)) {
+                    const keyRoot = key.split(".")[0];
+                    const isGenericNamespaced = keyRoot.startsWith("module-");
+                    const isAlreadyNamespaced = isGenericNamespaced ||
+                        key.startsWith(`${moduleName}.`) ||
+                        key.startsWith(`${moduleNamespace}.`);
+                    const normalizedKey = isAlreadyNamespaced
+                        ? key
+                        : `${moduleNamespace}.${key}`;
+                    translations[lang][normalizedKey] = value;
+                }
+            }
+            catch (error) {
+                console.warn(`  ⚠️  Error reading ${file}:`, error);
+            }
+        }
+        // Créer le dossier i18n s'il n'existe pas
+        ensureDirectory(appI18nDir);
+        // Écrire les fichiers de traduction
+        for (const [lang, content] of Object.entries(translations)) {
+            const filePath = path.join(appI18nDir, `${lang}.json`);
+            fs.writeFileSync(filePath, JSON.stringify(content, null, 2), "utf-8");
+            const keyCount = Object.keys(content).length;
+            if (isDebugMode) {
+                console.log(`✅ Generated ${filePath} (${keyCount} keys)`);
+            }
+        }
+    }
+    catch (error) {
+        console.error("❌ Error generating i18n files:", error);
+    }
+}
+/**
+ * Extrait le nom du module depuis le chemin du fichier
+ */
+function extractModuleNameFromPath(filePath) {
+    // packages/module-auth/src/i18n/fr.json -> module-auth
+    const parts = filePath.split(path.sep);
+    const packagesIndex = parts.indexOf("packages");
+    if (packagesIndex !== -1 && packagesIndex < parts.length - 1) {
+        return parts[packagesIndex + 1];
+    }
+    return "unknown";
+}
 export async function runModuleBuild() {
     ensureDirectory(appDirectory);
     // Nettoyer les fichiers générés précédemment
@@ -1206,6 +1501,11 @@ export async function runModuleBuild() {
         console.log("🧹 Cleaning previously generated files...");
     }
     cleanGeneratedFiles();
+    // Supprimer les anciennes routes sans [lang]
+    if (isDebugMode) {
+        console.log("🗑️  Removing old routes without [lang]...");
+    }
+    cleanOldRoutesWithoutLang();
     const moduleConfigs = await loadModuleConfigs();
     if (isDebugMode) {
         console.log(`🔍 Loaded ${moduleConfigs.length} module configurations`);
@@ -1227,10 +1527,12 @@ export async function runModuleBuild() {
     const apisByPath = new Map();
     moduleConfigs.forEach((moduleConfig) => {
         moduleConfig.apis.forEach((api) => {
-            if (!apisByPath.has(api.path)) {
-                apisByPath.set(api.path, []);
+            const apisForPath = apisByPath.get(api.path);
+            if (apisForPath) {
+                apisForPath.push({ moduleConfig, api });
+                return;
             }
-            apisByPath.get(api.path).push({ moduleConfig, api });
+            apisByPath.set(api.path, [{ moduleConfig, api }]);
         });
     });
     // Générer les fichiers de route groupés
@@ -1268,6 +1570,11 @@ export async function runModuleBuild() {
         console.log("🦶 Generating footer configuration...");
     }
     await generateFooterConfig(moduleConfigs);
+    // Générer les fichiers i18n
+    if (isDebugMode) {
+        console.log("🌍 Building i18n files...");
+    }
+    await generateI18nFiles();
     // Message de succès final
     if (!isDebugMode) {
         console.log("\n✅ Module build completed successfully!");