@lastbrain/app 0.1.25 → 0.1.26

package/src/scripts/module-build.ts

@@ -1,12 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 
 import type {
   ModuleApiConfig,
   ModuleBuildConfig,
-  ModuleMenuConfig,
   ModuleMenuItemConfig,
   ModulePageConfig,
   ModuleSection,
@@ -23,11 +21,11 @@ const projectRequire = createRequire(path.join(projectRoot, "package.json"));
 async function loadModuleConfigs(): Promise<ModuleBuildConfig[]> {
   const moduleConfigs: ModuleBuildConfig[] = [];
   const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
-  
+
   if (!fs.existsSync(modulesJsonPath)) {
     return moduleConfigs;
   }
-  
+
   try {
     const modulesData = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
     const modules = modulesData.modules || [];
@@ -37,9 +35,9 @@ async function loadModuleConfigs(): Promise<ModuleBuildConfig[]> {
       if (module.active === false) {
         continue;
       }
-      
+
       const packageName = module.package;
-      
+
       try {
         const moduleSuffix = packageName.replace("@lastbrain/module-", "");
         const possibleConfigNames = [
@@ -51,17 +49,19 @@ async function loadModuleConfigs(): Promise<ModuleBuildConfig[]> {
         for (const configName of possibleConfigNames) {
           try {
             // Résoudre le chemin du module depuis l'application
-            const modulePath = projectRequire.resolve(`${packageName}/${configName}`);
+            const modulePath = projectRequire.resolve(
+              `${packageName}/${configName}`,
+            );
             // Convertir en URL file:// pour l'import dynamique
             const moduleUrl = `file://${modulePath}`;
             const moduleImport = await import(moduleUrl);
-            
+
             if (moduleImport.default) {
               moduleConfigs.push(moduleImport.default);
               loaded = true;
               break;
             }
-          } catch (err) {
+          } catch {
             // Essayer le nom suivant
           }
         }
@@ -76,7 +76,7 @@ async function loadModuleConfigs(): Promise<ModuleBuildConfig[]> {
   } catch (error) {
     console.error("❌ Error loading modules.json:", error);
   }
-  
+
   return moduleConfigs;
 }
 
@@ -151,12 +151,34 @@ function toPascalCase(value: string) {
 }
 
 function buildPage(moduleConfig: ModuleBuildConfig, page: ModulePageConfig) {
-  const segments = page.path.replace(/^\/+/, "").split("/").filter(Boolean);
-  const sectionPath = sectionDirectoryMap[page.section] ?? ["(public)"];
+  // Extraire le préfixe du module (ex: @lastbrain/module-auth -> auth)
+  const modulePrefix = moduleConfig.moduleName
+    .replace(/^@lastbrain\/module-/, '')
+    .toLowerCase();
   
+  console.log(`🔄 Building page for module ${modulePrefix}: ${page.path}`);
+  
+  // Ajouter le préfixe du module au path pour les sections admin et auth, 
+  // MAIS seulement quand la section ne correspond PAS au module lui-même
+  let effectivePath = page.path;
+  if (page.section === 'admin' || (page.section === 'auth' && modulePrefix !== 'auth')) {
+    // Éviter les doublons si le préfixe est déjà présent
+    if (!page.path.startsWith(`/${modulePrefix}/`)) {
+      effectivePath = `/${modulePrefix}${page.path}`;
+      console.log(`📂 Added module prefix: ${page.path} -> ${effectivePath}`);
+    } else {
+      console.log(`✅ Module prefix already present: ${page.path}`);
+    }
+  } else if (page.section === 'auth' && modulePrefix === 'auth') {
+    console.log(`🏠 Auth module in auth section, no prefix needed: ${page.path}`);
+  }
+  
+  const segments = effectivePath.replace(/^\/+/, "").split("/").filter(Boolean);
+  const sectionPath = sectionDirectoryMap[page.section] ?? ["(public)"];
+
   // Générer le layout de section si nécessaire
   ensureSectionLayout(sectionPath);
-  
+
   const routeDir = path.join(appDirectory, ...sectionPath, ...segments);
   const filePath = path.join(routeDir, "page.tsx");
   ensureDirectory(routeDir);
@@ -167,17 +189,23 @@ function buildPage(moduleConfig: ModuleBuildConfig, page: ModulePageConfig) {
   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(']'));
+  const hasDynamicParams = segments.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" && 
-    (page.path.includes("signin") || page.path.includes("signup") || page.path.includes("reset-password"));
+  const isPublicAuthPage =
+    page.section === "public" &&
+    (page.path.includes("signin") ||
+      page.path.includes("signup") ||
+      page.path.includes("reset-password"));
 
   let content: string;
-  
+
   if (isPublicAuthPage) {
-    content = `"use client";
+    content = `// GENERATED BY LASTBRAIN MODULE BUILD
+"use client";
 
 import dynamic from "next/dynamic";
 
@@ -186,23 +214,25 @@ const ${page.componentExport} = dynamic(
   { ssr: false }
 );
 
-export default function ${wrapperName}${hasDynamicParams ? '(props: any)' : '()'} {
-  return <${page.componentExport} ${hasDynamicParams ? '{...props}' : ''} />;
+export default function ${wrapperName}${hasDynamicParams ? "(props: any)" : "()"} {
+  return <${page.componentExport} ${hasDynamicParams ? "{...props}" : ""} />;
 }
 `;
   } else {
-    content = `import { ${page.componentExport} } from "${moduleConfig.moduleName}";
+    content = `// GENERATED BY LASTBRAIN MODULE BUILD
+import { ${page.componentExport} } from "${moduleConfig.moduleName}";
 
-export default function ${wrapperName}${hasDynamicParams ? '(props: any)' : '()'} {
-  return <${page.componentExport} ${hasDynamicParams ? '{...props}' : ''} />;
+export default function ${wrapperName}${hasDynamicParams ? "(props: any)" : "()"} {
+  return <${page.componentExport} ${hasDynamicParams ? "{...props}" : ""} />;
 }
 `;
   }
 
   fs.writeFileSync(filePath, content);
-  console.log(`⭐ Generated page: ${filePath}`);  const entry: MenuEntry = {
+  console.log(`⭐ Generated page: ${filePath}`);
+  const entry: MenuEntry = {
     label: `Module:${moduleConfig.moduleName} ${page.componentExport}`,
-    path: page.path,
+    path: effectivePath,
     module: moduleConfig.moduleName,
     section: page.section,
   };
@@ -214,22 +244,6 @@ export default function ${wrapperName}${hasDynamicParams ? '(props: any)' : '()'
   }
 }
 
-function buildApi(moduleConfig: ModuleBuildConfig, api: ModuleApiConfig) {
-  const segments = api.path.replace(/^\/+/, "").split("/").filter(Boolean);
-  const sanitizedSegments =
-    segments[0] === "api" ? segments.slice(1) : segments;
-  const routeDir = path.join(appDirectory, "api", ...sanitizedSegments);
-  const filePath = path.join(routeDir, "route.ts");
-  ensureDirectory(routeDir);
-
-  const handler = `${moduleConfig.moduleName}/${api.entryPoint}`;
-  const content = `export { ${api.handlerExport} } from "${handler}";
-`;
-
-  fs.writeFileSync(filePath, content);
-  console.log(`🔌 Generated API route: ${filePath}`);
-}
-
 function dumpNavigation() {
   const navPath = path.join(appDirectory, "navigation.generated.ts");
   const content = `export type MenuEntry = { label: string; path: string; module: string; section: string };
@@ -248,15 +262,15 @@ export const userMenu = ${JSON.stringify(userMenu, null, 2)};
 function generateMenuConfig(moduleConfigs: ModuleBuildConfig[]) {
   const configDir = path.join(projectRoot, "config");
   ensureDirectory(configDir);
-  
+
   const menuPath = path.join(configDir, "menu.ts");
-  
+
   // Collecter les menus de tous les modules
   const publicMenus: ModuleMenuItemConfig[] = [];
   const authMenus: ModuleMenuItemConfig[] = [];
   const adminMenus: ModuleMenuItemConfig[] = [];
   const accountMenus: ModuleMenuItemConfig[] = [];
-  
+
   moduleConfigs.forEach((moduleConfig: ModuleBuildConfig) => {
     if (moduleConfig.menu) {
       if (moduleConfig.menu.public) {
@@ -273,17 +287,17 @@ function generateMenuConfig(moduleConfigs: ModuleBuildConfig[]) {
       }
     }
   });
-  
+
   // Trier par ordre
   const sortByOrder = (a: ModuleMenuItemConfig, b: ModuleMenuItemConfig) => {
     return (a.order ?? 999) - (b.order ?? 999);
   };
-  
+
   publicMenus.sort(sortByOrder);
   authMenus.sort(sortByOrder);
   adminMenus.sort(sortByOrder);
   accountMenus.sort(sortByOrder);
-  
+
   // Générer le contenu du fichier
   const content = `// Auto-generated menu configuration
 // Generated from module build configs
@@ -310,32 +324,38 @@ export const menuConfig: MenuConfig = {
   account: ${JSON.stringify(accountMenus, null, 2)},
 };
 `;
-  
+
   fs.writeFileSync(menuPath, content);
   console.log(`🍔 Generated menu configuration: ${menuPath}`);
 }
 
 function copyModuleMigrations(moduleConfigs: ModuleBuildConfig[]) {
-  const supabaseMigrationsDir = path.join(projectRoot, "supabase", "migrations");
-  
+  const supabaseMigrationsDir = path.join(
+    projectRoot,
+    "supabase",
+    "migrations",
+  );
+
   // S'assurer que le dossier migrations existe
   if (!fs.existsSync(supabaseMigrationsDir)) {
     ensureDirectory(supabaseMigrationsDir);
   }
 
   const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
-  
+
   // Charger modules.json
-  let modulesConfig: { modules: Array<{ package: string; migrations?: string[] }> } = { modules: [] };
+  let modulesConfig: {
+    modules: Array<{ package: string; migrations?: string[] }>;
+  } = { modules: [] };
   if (fs.existsSync(modulesJsonPath)) {
     modulesConfig = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
   }
-  
+
   moduleConfigs.forEach((moduleConfig: ModuleBuildConfig) => {
     try {
       const moduleName = moduleConfig.moduleName;
       const copiedMigrations: string[] = [];
-      
+
       // Essayer plusieurs chemins possibles pour trouver le module
       const possiblePaths = [
         // Dans node_modules local de l'app
@@ -343,32 +363,42 @@ function copyModuleMigrations(moduleConfigs: ModuleBuildConfig[]) {
         // Dans node_modules à la racine du workspace
         path.join(projectRoot, "..", "..", "node_modules", moduleName),
         // Directement dans packages/ (pour monorepo)
-        path.join(projectRoot, "..", "..", "packages", moduleName.replace("@lastbrain/", "")),
+        path.join(
+          projectRoot,
+          "..",
+          "..",
+          "packages",
+          moduleName.replace("@lastbrain/", ""),
+        ),
       ];
-      
+
       let moduleBasePath: string | null = null;
-      
+
       for (const possiblePath of possiblePaths) {
         if (fs.existsSync(possiblePath)) {
           moduleBasePath = possiblePath;
           break;
         }
       }
-      
+
       if (!moduleBasePath) {
         return;
       }
-      
-      const moduleMigrationsDir = path.join(moduleBasePath, "supabase", "migrations");
-      
+
+      const moduleMigrationsDir = path.join(
+        moduleBasePath,
+        "supabase",
+        "migrations",
+      );
+
       if (fs.existsSync(moduleMigrationsDir)) {
         const migrationFiles = fs.readdirSync(moduleMigrationsDir);
-        
+
         migrationFiles.forEach((file) => {
           if (file.endsWith(".sql")) {
             const sourcePath = path.join(moduleMigrationsDir, file);
             const destPath = path.join(supabaseMigrationsDir, file);
-            
+
             // Copier seulement si le fichier n'existe pas déjà
             if (!fs.existsSync(destPath)) {
               fs.copyFileSync(sourcePath, destPath);
@@ -378,13 +408,13 @@ function copyModuleMigrations(moduleConfigs: ModuleBuildConfig[]) {
           }
         });
       }
-      
+
       // Mettre à jour modules.json avec les migrations
       if (copiedMigrations.length > 0) {
         const moduleIndex = modulesConfig.modules.findIndex(
-          (m) => m.package === moduleName
+          (m) => m.package === moduleName,
         );
-        
+
         if (moduleIndex >= 0) {
           modulesConfig.modules[moduleIndex].migrations = copiedMigrations;
         } else {
@@ -395,10 +425,13 @@ function copyModuleMigrations(moduleConfigs: ModuleBuildConfig[]) {
         }
       }
     } catch (error) {
-      console.warn(`⚠️  Could not copy migrations from ${moduleConfig.moduleName}:`, error);
+      console.warn(
+        `⚠️  Could not copy migrations from ${moduleConfig.moduleName}:`,
+        error,
+      );
     }
   });
-  
+
   // Sauvegarder modules.json avec les migrations mises à jour
   ensureDirectory(path.dirname(modulesJsonPath));
   fs.writeFileSync(modulesJsonPath, JSON.stringify(modulesConfig, null, 2));
@@ -407,13 +440,17 @@ function copyModuleMigrations(moduleConfigs: ModuleBuildConfig[]) {
 function generateDocsPage(moduleConfigs: ModuleBuildConfig[]) {
   const docsDir = path.join(appDirectory, "docs");
   ensureDirectory(docsDir);
-  
+
   const docsPagePath = path.join(docsDir, "page.tsx");
-  
+
   // Charger tous les modules depuis modules.json (actifs ET inactifs)
   const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
-  let allModules: Array<{ package: string; active: boolean; migrations?: string[] }> = [];
-  
+  let allModules: Array<{
+    package: string;
+    active: boolean;
+    migrations?: string[];
+  }> = [];
+
   if (fs.existsSync(modulesJsonPath)) {
     try {
       const modulesData = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
@@ -422,25 +459,29 @@ function generateDocsPage(moduleConfigs: ModuleBuildConfig[]) {
       console.error("❌ Error reading modules.json:", error);
     }
   }
-  
+
   // Générer les imports des composants Doc de chaque module
   const docImports: string[] = [];
   const moduleConfigurations: string[] = [];
-  
+
   allModules.forEach((moduleEntry) => {
     const moduleName = moduleEntry.package;
     const moduleId = moduleName.replace("@lastbrain/module-", "");
     const docComponentName = `${toPascalCase(moduleId)}ModuleDoc`;
-    
+
     // Trouver la config du module pour obtenir la description
-    const moduleConfig = moduleConfigs.find(mc => mc.moduleName === moduleName);
-    const description = moduleConfig ? getModuleDescription(moduleConfig) : "Module non configuré";
-    
+    const moduleConfig = moduleConfigs.find(
+      (mc) => mc.moduleName === moduleName,
+    );
+    const description = moduleConfig
+      ? getModuleDescription(moduleConfig)
+      : "Module non configuré";
+
     // Importer le composant Doc seulement pour les modules actifs
     if (moduleEntry.active) {
       docImports.push(`import { ${docComponentName} } from "${moduleName}";`);
     }
-    
+
     const config = {
       id: moduleId,
       name: `Module ${moduleId.charAt(0).toUpperCase() + moduleId.slice(1)}`,
@@ -448,34 +489,68 @@ function generateDocsPage(moduleConfigs: ModuleBuildConfig[]) {
       component: docComponentName,
       active: moduleEntry.active,
     };
-    
+
     moduleConfigurations.push(`  {
     id: "${config.id}",
     name: "${config.name}",
     description: "${config.description}",
-    ${config.active ? `content: <${config.component} />,` : 'content: null,'}
+    ${config.active ? `content: <${config.component} />,` : "content: null,"}
     available: ${config.active},
   }`);
   });
-  
+
   const docsContent = `// Auto-generated docs page with module documentation
 import React from "react";
 import { DocPage } from "@lastbrain/app";
-${docImports.join('\n')}
+${docImports.join("\n")}
 
 export default function DocsPage() {
   const modules = [
-${moduleConfigurations.join(',\n')}
+${moduleConfigurations.join(",\n")}
   ];
   
   return <DocPage modules={modules} />;
 }
 `;
-  
+
   fs.writeFileSync(docsPagePath, docsContent);
   console.log(`📚 Generated docs page: ${docsPagePath}`);
 }
 
+function buildGroupedApi(apis: Array<{ moduleConfig: ModuleBuildConfig; api: ModuleApiConfig }>, routePath: string) {
+  const segments = routePath.replace(/^\/+/, "").split("/").filter(Boolean);
+  const sanitizedSegments = segments[0] === "api" ? segments.slice(1) : segments;
+  const routeDir = path.join(appDirectory, "api", ...sanitizedSegments);
+  const filePath = path.join(routeDir, "route.ts");
+  ensureDirectory(routeDir);
+
+  // Grouper par module/entryPoint pour créer les exports
+  const exportsBySource = new Map<string, string[]>();
+  
+  apis.forEach(({ moduleConfig, api }) => {
+    const handler = `${moduleConfig.moduleName}/${api.entryPoint}`;
+    if (!exportsBySource.has(handler)) {
+      exportsBySource.set(handler, []);
+    }
+    exportsBySource.get(handler)!.push(api.handlerExport);
+  });
+
+  // Générer les exports - un export statement par source
+  const exportStatements: string[] = [];
+  exportsBySource.forEach((exports, source) => {
+    exportStatements.push(`export { ${exports.join(", ")} } from "${source}";`);
+  });
+
+  const content = exportStatements.join("\n") + "\n";
+  
+  // Ajouter le marqueur de génération au début
+  const contentWithMarker = `// GENERATED BY LASTBRAIN MODULE BUILD
+${content}`;
+  
+  fs.writeFileSync(filePath, contentWithMarker);
+  console.log(`🔌 Generated API route: ${filePath}`);
+}
+
 function getModuleDescription(moduleConfig: ModuleBuildConfig): string {
   // Essayer de déduire la description depuis les pages ou retourner une description par défaut
   if (moduleConfig.pages.length > 0) {
@@ -484,19 +559,249 @@ function getModuleDescription(moduleConfig: ModuleBuildConfig): string {
   return "Module documentation";
 }
 
+function cleanGeneratedFiles() {
+  const generatedComment = "// GENERATED BY LASTBRAIN MODULE BUILD";
+  
+  // Fichiers de base à préserver (paths relatifs exacts)
+  const protectedFiles = new Set([
+    // API de base
+    "api/storage",
+    // Layouts de base
+    "layout.tsx",
+    "not-found.tsx", 
+    "page.tsx",  // Page racine seulement
+    "admin/page.tsx",  // Page admin racine
+    "admin/layout.tsx",  // Layout admin racine
+    "docs/page.tsx",  // Page docs générée
+    // Middleware et autres fichiers core
+    "middleware.ts",
+    // Dossiers de lib et config
+    "lib",
+    "config"
+  ]);
+
+  // Fonction pour vérifier si un chemin est protégé
+  const isProtected = (filePath: string) => {
+    const relativePath = path.relative(appDirectory, filePath);
+    
+    // Protection exacte pour certains fichiers
+    if (protectedFiles.has(relativePath)) {
+      return true;
+    }
+    
+    // Protection par préfixe pour les dossiers
+    return Array.from(protectedFiles).some(protectedPath => 
+      (protectedPath.endsWith('/') || ['lib', 'config', 'api/storage'].includes(protectedPath)) &&
+      relativePath.startsWith(protectedPath)
+    );
+  };
+
+  // Fonction pour nettoyer récursivement un dossier
+  const cleanDirectory = (dirPath: string) => {
+    if (!fs.existsSync(dirPath)) return;
+    
+    const items = fs.readdirSync(dirPath);
+    
+    for (const item of items) {
+      const itemPath = path.join(dirPath, item);
+      const stat = fs.statSync(itemPath);
+      
+      if (stat.isDirectory()) {
+        // Nettoyer récursivement le sous-dossier
+        cleanDirectory(itemPath);
+        
+        // Supprimer le dossier s'il est vide et non protégé
+        try {
+          if (!isProtected(itemPath) && fs.readdirSync(itemPath).length === 0) {
+            fs.rmdirSync(itemPath);
+            console.log(`🗑️ Removed empty directory: ${itemPath}`);
+          }
+        } catch (e) {
+          // Ignorer les erreurs de suppression de dossiers
+        }
+      } else if (item.endsWith('.tsx') || item.endsWith('.ts')) {
+        // Vérifier si c'est un fichier généré
+        if (!isProtected(itemPath)) {
+          try {
+            const content = fs.readFileSync(itemPath, 'utf-8');
+            // Supprimer les fichiers générés ou les wrapper simples de modules
+            if (content.includes(generatedComment) || 
+                content.includes('from "@lastbrain/module-') || 
+                content.includes('export {') && content.includes('} from "@lastbrain/module-')) {
+              fs.unlinkSync(itemPath);
+              console.log(`🗑️ Cleaned generated file: ${itemPath}`);
+            }
+          } catch (e) {
+            // Ignorer les erreurs de lecture/suppression
+          }
+        } else {
+          console.log(`🔒 Protected file skipped: ${itemPath}`);
+        }
+      }
+    }
+  };
+
+  // Nettoyer les dossiers de sections
+  const sectionsToClean = ['(public)', 'auth', 'admin', 'api'];
+  sectionsToClean.forEach(section => {
+    const sectionPath = path.join(appDirectory, section);
+    if (fs.existsSync(sectionPath)) {
+      cleanDirectory(sectionPath);
+    }
+  });
+
+  // Nettoyer les fichiers générés à la racine
+  const rootFiles = ['navigation.generated.ts'];
+  rootFiles.forEach(file => {
+    const filePath = path.join(appDirectory, file);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      console.log(`🗑️ Cleaned root file: ${filePath}`);
+    }
+  });
+
+  console.log("🧹 Cleanup completed");
+}
+
+function generateAppAside() {
+  const targetPath = path.join(appDirectory, "components", "AppAside.tsx");
+  
+  // Ne pas écraser si le fichier existe déjà
+  if (fs.existsSync(targetPath)) {
+    console.log(`⏭️ AppAside already exists, skipping: ${targetPath}`);
+    return;
+  }
+
+  const templateContent = `"use client";
+
+import { AppAside as UIAppAside } from "@lastbrain/app";
+import { useAuthSession } from "@lastbrain/app";
+import { menuConfig } from "../../config/menu";
+
+interface AppAsideProps {
+  className?: string;
+  isVisible?: boolean;
+}
+
+export function AppAside({ className = "", isVisible = true }: AppAsideProps) {
+  const { isSuperAdmin } = useAuthSession();
+
+  return (
+    <UIAppAside
+      className={className}
+      menuConfig={menuConfig}
+      isSuperAdmin={isSuperAdmin}
+      isVisible={isVisible}
+    />
+  );
+}`;
+
+  try {
+    ensureDirectory(path.dirname(targetPath));
+    fs.writeFileSync(targetPath, templateContent, "utf-8");
+    console.log(`✅ Generated AppAside component: ${targetPath}`);
+  } 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";
+import { menuConfig } from "../../config/menu";
+
+export default function SectionLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <AuthLayoutWithSidebar menuConfig={menuConfig}>
+      {children}
+    </AuthLayoutWithSidebar>
+  );
+}`;
+
+    try {
+      ensureDirectory(path.dirname(authLayoutPath));
+      fs.writeFileSync(authLayoutPath, authLayoutContent, "utf-8");
+      console.log(`✅ Generated auth layout with sidebar: ${authLayoutPath}`);
+    } catch (error) {
+      console.error(`❌ Error generating auth layout: ${error}`);
+    }
+  } else {
+    console.log(`⏭️ Auth layout already exists, skipping: ${authLayoutPath}`);
+  }
+
+  // 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";
+
+export default function AdminLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <AdminLayoutWithSidebar menuConfig={menuConfig}>
+      {children}
+    </AdminLayoutWithSidebar>
+  );
+}`;
+
+    try {
+      ensureDirectory(path.dirname(adminLayoutPath));
+      fs.writeFileSync(adminLayoutPath, adminLayoutContent, "utf-8");
+      console.log(`✅ Generated admin layout with sidebar: ${adminLayoutPath}`);
+    } catch (error) {
+      console.error(`❌ Error generating admin layout: ${error}`);
+    }
+  } else {
+    console.log(`⏭️ Admin layout already exists, skipping: ${adminLayoutPath}`);
+  }
+}
+
 export async function runModuleBuild() {
   ensureDirectory(appDirectory);
 
+  // Nettoyer les fichiers générés précédemment
+  console.log("🧹 Cleaning previously generated files...");
+  cleanGeneratedFiles();
+
   const moduleConfigs = await loadModuleConfigs();
+  console.log(`🔍 Loaded ${moduleConfigs.length} module configurations`);
+  
+  // Générer les pages
   moduleConfigs.forEach((moduleConfig) => {
+    console.log(`📦 Processing module: ${moduleConfig.moduleName} with ${moduleConfig.pages.length} pages`);
     moduleConfig.pages.forEach((page) => buildPage(moduleConfig, page));
-    moduleConfig.apis.forEach((api) => buildApi(moduleConfig, api));
+  });
+
+  // Grouper les APIs par chemin pour éviter les écrasements de fichier
+  const apisByPath = new Map<string, Array<{ moduleConfig: ModuleBuildConfig; api: ModuleApiConfig }>>();
+  
+  moduleConfigs.forEach((moduleConfig) => {
+    moduleConfig.apis.forEach((api) => {
+      if (!apisByPath.has(api.path)) {
+        apisByPath.set(api.path, []);
+      }
+      apisByPath.get(api.path)!.push({ moduleConfig, api });
+    });
+  });
+
+  // Générer les fichiers de route groupés
+  apisByPath.forEach((apis, routePath) => {
+    buildGroupedApi(apis, routePath);
   });
 
   dumpNavigation();
   generateMenuConfig(moduleConfigs);
   generateDocsPage(moduleConfigs);
+  generateAppAside();
+  generateLayouts();
   copyModuleMigrations(moduleConfigs);
 }
-
-runModuleBuild();