@lastbrain/app 2.0.1 → 2.0.2

package/dist/src/scripts/init-app.js

@@ -0,0 +1,2175 @@
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { execSync } from "child_process";
+import { AVAILABLE_MODULES } from "@lastbrain/core/config/modules";
+import { PACKAGE_VERSIONS } from "../../config/version.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function initApp(options) {
+    const { targetDir, force, projectName, useHeroUI, interactive = true, } = options;
+    let { withAuth = false, isMonorepoProject = false } = options;
+    console.log(chalk.blue("\n🚀 LastBrain App Init\n"));
+    console.log(chalk.gray(`📁 Dossier cible: ${targetDir}`));
+    if (useHeroUI) {
+        console.log(chalk.magenta(`🎨 Mode: HeroUI\n`));
+    }
+    else {
+        console.log(chalk.gray(`🎨 Mode: Tailwind CSS only\n`));
+    }
+    // Sélection interactive des modules
+    const selectedModules = [];
+    if (interactive && !withAuth) {
+        console.log(chalk.blue("📦 Sélection des modules:\n"));
+        const answers = await inquirer.prompt([
+            {
+                type: "checkbox",
+                name: "modules",
+                message: "Quels modules voulez-vous installer ?",
+                choices: AVAILABLE_MODULES.map((module) => ({
+                    name: `${module.emoji} ${module.name.charAt(0).toUpperCase() + module.name.slice(1)} - ${module.description}`,
+                    value: module.name,
+                    checked: false,
+                })),
+            },
+            {
+                type: "rawlist",
+                name: "projectType",
+                message: "Type de projet ?",
+                choices: [
+                    {
+                        name: "📦 Indépendant (créer une nouvelle BDD Supabase)",
+                        value: "independent",
+                    },
+                    {
+                        name: "🏢 Monorepo (utiliser la BDD existante)",
+                        value: "monorepo",
+                    },
+                ],
+                default: "independent",
+            },
+        ]);
+        selectedModules.push(...answers.modules);
+        withAuth = selectedModules.includes("auth");
+        isMonorepoProject = answers.projectType === "monorepo";
+        if (isMonorepoProject) {
+            console.log(chalk.cyan("\n💡 Mode monorepo activé:"), chalk.gray("Votre app utilisera la base de données centralisée du monorepo."));
+            console.log(chalk.gray("   Aucune configuration Supabase locale ne sera créée.\n"));
+        }
+        else {
+            console.log(chalk.cyan("\n💡 Mode projet indépendant activé:"), chalk.gray("Votre app aura sa propre instance Supabase locale."));
+            console.log(chalk.gray("   Configuration complète sera créée.\n"));
+        }
+        console.log();
+    }
+    else if (!interactive) {
+        // En mode non-interactif, installer auth et ai par défaut
+        selectedModules.push("auth", "ai");
+        withAuth = true;
+        isMonorepoProject = false;
+        console.log(chalk.blue("📦 Modules installés par défaut : Authentication, AI Generation\n"));
+    }
+    // Créer le dossier s'il n'existe pas
+    await fs.ensureDir(targetDir);
+    // 1. Vérifier/créer package.json
+    await ensurePackageJson(targetDir, projectName);
+    // 2. Installer les dépendances
+    await addDependencies(targetDir, useHeroUI, withAuth, selectedModules);
+    // 3. Créer la structure Next.js
+    await createNextStructure(targetDir, force, useHeroUI, withAuth);
+    // 4. Créer les fichiers de configuration
+    await createConfigFiles(targetDir, force, useHeroUI, projectName);
+    // 5. Créer le système de proxy storage
+    await createStorageProxy(targetDir, force);
+    // 6. Créer .gitignore et .env.local.example
+    await createGitIgnore(targetDir, force);
+    await createEnvExample(targetDir, force);
+    await createEnvLocal(targetDir, force, isMonorepoProject);
+    await createEnvProd(targetDir, force);
+    // 7. Créer la structure Supabase avec migrations (seulement pour projets indépendants)
+    if (!isMonorepoProject) {
+        console.log(chalk.blue("🗄️  Création de la structure Supabase locale...\n"));
+        await createSupabaseStructure(targetDir, force);
+    }
+    else {
+        console.log(chalk.yellow("⏭️  Projet monorepo détecté - pas de configuration Supabase locale requise\n"));
+    }
+    // 8. Ajouter les scripts NPM
+    await addScriptsToPackageJson(targetDir);
+    // 9. Enregistrer les modules sélectionnés
+    if (withAuth && !selectedModules.includes("auth")) {
+        selectedModules.push("auth");
+    }
+    if (selectedModules.length > 0) {
+        await saveModulesConfig(targetDir, selectedModules, withAuth);
+    }
+    console.log(chalk.green("\n✅ Application LastBrain initialisée avec succès!\n"));
+    const relativePath = path.relative(process.cwd(), targetDir);
+    // Demander si l'utilisateur veut lancer l'installation et le dev server
+    const { launchNow } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "launchNow",
+            message: "Voulez-vous installer les dépendances et lancer le serveur de développement maintenant ?",
+            default: true,
+        },
+    ]);
+    if (launchNow) {
+        console.log(chalk.yellow("\n📦 Installation des dépendances...\n"));
+        try {
+            execSync("pnpm install", { cwd: targetDir, stdio: "inherit" });
+            console.log(chalk.green("\n✓ Dépendances installées\n"));
+            console.log(chalk.yellow("🔧 Génération des routes des modules...\n"));
+            execSync("pnpm build:modules", { cwd: targetDir, stdio: "inherit" });
+            console.log(chalk.green("\n✓ Routes des modules générées\n"));
+            console.log(chalk.yellow("📜 Synchronisation des migrations des modules...\n"));
+            try {
+                execSync("pnpm db:migrations:sync", {
+                    cwd: targetDir,
+                    stdio: "inherit",
+                });
+                console.log(chalk.green("\n✓ Migrations synchronisées\n"));
+            }
+            catch (_error) {
+                console.log(chalk.yellow("\n⚠️  Erreur de synchronisation des migrations\n"));
+            }
+            // Ne pas initialiser la BDD en mode monorepo
+            if (!isMonorepoProject) {
+                console.log(chalk.yellow("🗄️ Initialisation de la base de données...\n"));
+                try {
+                    execSync("pnpm db:init", { cwd: targetDir, stdio: "inherit" });
+                    console.log(chalk.green("\n✓ Base de données initialisée\n"));
+                }
+                catch {
+                    console.log(chalk.yellow("\n⚠️  Erreur d'initialisation de la DB (normal si Supabase pas configuré)\n"));
+                }
+            }
+            else {
+                console.log(chalk.cyan("⏭️  Mode monorepo détecté - BDD centralisée, pas d'initialisation locale requise\n"));
+            }
+            // Détecter le port (par défaut 3000 pour Next.js)
+            const port = 3000;
+            const url = `http://127.0.0.1:${port}`;
+            console.log(chalk.yellow("🚀 Lancement du serveur de développement...\n"));
+            console.log(chalk.cyan(`📱 Ouvrez votre navigateur sur : ${url}\n`));
+            console.log(chalk.blue("\n📋 Prochaines étapes après le démarrage :"));
+            console.log(chalk.white("  1. Cliquez sur 'Get Started' sur la page d'accueil"));
+            if (isMonorepoProject) {
+                console.log(chalk.white("  2. La BDD est centralisée dans le monorepo\n"));
+            }
+            else {
+                console.log(chalk.white("  2. Lancez Docker Desktop"));
+                console.log(chalk.white("  3. Installez Supabase CLI si nécessaire : brew install supabase/tap/supabase"));
+                console.log(chalk.white("  4. Exécutez : pnpm db:init"));
+                console.log(chalk.white("  5. Rechargez la page\n"));
+            }
+            // Ouvrir le navigateur
+            const openCommand = process.platform === "darwin"
+                ? "open"
+                : process.platform === "win32"
+                    ? "start"
+                    : "xdg-open";
+            setTimeout(() => {
+                try {
+                    execSync(`${openCommand} ${url}`, { stdio: "ignore" });
+                }
+                catch {
+                    // Ignorer les erreurs d'ouverture du navigateur
+                }
+            }, 2000);
+            // Lancer pnpm dev
+            execSync("pnpm dev:local", { cwd: targetDir, stdio: "inherit" });
+        }
+        catch {
+            console.error(chalk.red("\n❌ Erreur lors du lancement\n"));
+            console.log(chalk.cyan("\nVous pouvez lancer manuellement avec :"));
+            console.log(chalk.white(`  cd ${relativePath}`));
+            console.log(chalk.white("  pnpm install"));
+            console.log(chalk.white("  pnpm build:modules"));
+            console.log(chalk.white("  pnpm db:migrations:sync"));
+            if (!isMonorepoProject) {
+                console.log(chalk.white("  pnpm db:init"));
+            }
+            console.log(chalk.white("  pnpm dev:local (ou pnpm dev:prod)\n"));
+        }
+    }
+    else {
+        console.log(chalk.cyan("\n📋 Prochaines étapes:"));
+        console.log(chalk.white("  1. cd " + relativePath));
+        console.log(chalk.white("  2. pnpm install (installer les dépendances)"));
+        console.log(chalk.white("  3. pnpm build:modules (générer les routes des modules)"));
+        console.log(chalk.white("  4. pnpm db:migrations:sync (synchroniser les migrations)"));
+        console.log(chalk.white("  5. pnpm db:init (initialiser la base de données)"));
+        console.log(chalk.white("  6. pnpm dev:local (ou pnpm dev:prod)\n"));
+        console.log(chalk.cyan("\n💡 Scripts disponibles:"));
+        console.log(chalk.white("  • pnpm dev:local  - Lance avec .env.local"));
+        console.log(chalk.white("  • pnpm dev:prod   - Lance avec .env.prod"));
+        console.log(chalk.white("  • pnpm dev        - Lance avec .env actuel\n"));
+        console.log(chalk.gray("Prérequis pour Supabase :"));
+        console.log(chalk.white("  - Docker Desktop installé et lancé"));
+        console.log(chalk.white("  - Supabase CLI : brew install supabase/tap/supabase\n"));
+        // Afficher la commande cd pour faciliter la copie
+        console.log(chalk.gray("Pour vous déplacer dans le projet :"));
+        console.log(chalk.cyan(`  cd ${relativePath}\n`));
+    }
+}
+async function ensurePackageJson(targetDir, projectName) {
+    const pkgPath = path.join(targetDir, "package.json");
+    if (!fs.existsSync(pkgPath)) {
+        console.log(chalk.yellow("📦 Création de package.json..."));
+        const pkg = {
+            name: projectName || path.basename(targetDir),
+            version: "0.1.0",
+            private: true,
+            type: "module",
+            scripts: {},
+            dependencies: {},
+            devDependencies: {},
+        };
+        await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+        console.log(chalk.green("✓ package.json créé"));
+    }
+    else {
+        console.log(chalk.green("✓ package.json existe"));
+    }
+}
+/**
+ * Récupère les versions actuelles des packages LastBrain depuis npm ou le monorepo
+ */
+function getLastBrainVersions(targetDir) {
+    const targetIsInMonorepo = fs.existsSync(path.join(targetDir, "../../../packages/core/package.json")) ||
+        fs.existsSync(path.join(targetDir, "../../packages/core/package.json"));
+    if (targetIsInMonorepo) {
+        // Dans le monorepo, utiliser workspace:*
+        return {
+            app: "workspace:*",
+            core: "workspace:*",
+            ui: "workspace:*",
+            moduleAuth: "workspace:*",
+            moduleAi: "workspace:*",
+        };
+    }
+    // Hors monorepo, utiliser les versions publiées
+    return {
+        app: PACKAGE_VERSIONS["@lastbrain/app"],
+        core: PACKAGE_VERSIONS["@lastbrain/core"],
+        ui: PACKAGE_VERSIONS["@lastbrain/ui"],
+        moduleAuth: PACKAGE_VERSIONS["@lastbrain/module-auth"],
+        moduleAi: PACKAGE_VERSIONS["@lastbrain/module-ai"],
+    };
+}
+async function addDependencies(targetDir, useHeroUI, withAuth, selectedModules = []) {
+    const pkgPath = path.join(targetDir, "package.json");
+    const pkg = await fs.readJson(pkgPath);
+    console.log(chalk.yellow("\n📦 Configuration des dépendances..."));
+    const versions = getLastBrainVersions(targetDir);
+    // Dependencies
+    const requiredDeps = {
+        next: "^15.0.3",
+        react: "^18.3.1",
+        "react-dom": "^18.3.1",
+        "@lastbrain/app": versions.app,
+        "@lastbrain/core": versions.core,
+        "@lastbrain/ui": versions.ui,
+        "next-themes": "^0.4.6",
+        pino: "^10.1.0",
+        "pino-pretty": "^13.1.2",
+    };
+    // Ajouter module-auth si demandé
+    if (withAuth) {
+        requiredDeps["@lastbrain/module-auth"] = versions.moduleAuth;
+    }
+    // Ajouter les autres modules sélectionnés
+    for (const moduleName of selectedModules) {
+        const moduleInfo = AVAILABLE_MODULES.find((m) => m.name === moduleName);
+        if (moduleInfo && moduleInfo.package !== "@lastbrain/module-auth") {
+            // Utiliser les vraies versions au lieu de "latest"
+            if (moduleInfo.package === "@lastbrain/module-ai") {
+                requiredDeps[moduleInfo.package] = versions.moduleAi;
+            }
+            else {
+                // Pour les futurs modules, utiliser "latest" en attendant
+                requiredDeps[moduleInfo.package] = "latest";
+            }
+        }
+    }
+    // Ajouter les dépendances HeroUI si nécessaire
+    if (useHeroUI) {
+        // Tous les packages HeroUI nécessaires (car @lastbrain/ui les ré-exporte)
+        requiredDeps["@heroui/system"] = "^2.4.23";
+        requiredDeps["@heroui/theme"] = "^2.4.23";
+        requiredDeps["@heroui/accordion"] = "^2.2.24";
+        requiredDeps["@heroui/alert"] = "^2.2.27";
+        requiredDeps["@heroui/autocomplete"] = "^2.3.29";
+        requiredDeps["@heroui/avatar"] = "^2.2.22";
+        requiredDeps["@heroui/badge"] = "^2.2.17";
+        requiredDeps["@heroui/breadcrumbs"] = "^2.2.22";
+        requiredDeps["@heroui/button"] = "^2.2.27";
+        requiredDeps["@heroui/card"] = "^2.2.25";
+        requiredDeps["@heroui/checkbox"] = "^2.3.27";
+        requiredDeps["@heroui/chip"] = "^2.2.22";
+        requiredDeps["@heroui/code"] = "^2.2.21";
+        requiredDeps["@heroui/divider"] = "^2.2.20";
+        requiredDeps["@heroui/drawer"] = "^2.2.24";
+        requiredDeps["@heroui/dropdown"] = "^2.3.27";
+        requiredDeps["@heroui/form"] = "^2.1.27";
+        requiredDeps["@heroui/input"] = "^2.4.28";
+        requiredDeps["@heroui/link"] = "^2.2.23";
+        requiredDeps["@heroui/listbox"] = "^2.3.26";
+        requiredDeps["@heroui/modal"] = "^2.2.24";
+        requiredDeps["@heroui/navbar"] = "^2.2.25";
+        requiredDeps["@heroui/pagination"] = "^2.2.24";
+        requiredDeps["@heroui/popover"] = "^2.3.27";
+        requiredDeps["@heroui/progress"] = "^2.2.22";
+        requiredDeps["@heroui/radio"] = "^2.3.27";
+        requiredDeps["@heroui/scroll-shadow"] = "^2.3.18";
+        requiredDeps["@heroui/select"] = "^2.4.28";
+        requiredDeps["@heroui/skeleton"] = "^2.2.17";
+        requiredDeps["@heroui/snippet"] = "^2.2.28";
+        requiredDeps["@heroui/spacer"] = "^2.2.21";
+        requiredDeps["@heroui/spinner"] = "^2.2.24";
+        requiredDeps["@heroui/switch"] = "^2.2.24";
+        requiredDeps["@heroui/table"] = "^2.2.27";
+        requiredDeps["@heroui/tabs"] = "^2.2.24";
+        requiredDeps["@heroui/toast"] = "^2.0.17";
+        requiredDeps["@heroui/tooltip"] = "^2.2.24";
+        requiredDeps["@heroui/user"] = "^2.2.22";
+        // Dependencies
+        requiredDeps["lucide-react"] = "^0.554.0";
+        requiredDeps["framer-motion"] = "^11.18.2";
+        requiredDeps["clsx"] = "^2.1.1";
+        requiredDeps["env-cmd"] = "^11.0.0";
+    }
+    // DevDependencies
+    const requiredDevDeps = {
+        tailwindcss: "^4.1.0",
+        "@tailwindcss/postcss": "^4.1.0",
+        postcss: "^8.4.0",
+        typescript: "^5.4.0",
+        "@types/node": "^20.0.0",
+        "@types/react": "^18.3.0",
+        "@types/react-dom": "^18.3.0",
+    };
+    pkg.dependencies = { ...pkg.dependencies, ...requiredDeps };
+    pkg.devDependencies = { ...pkg.devDependencies, ...requiredDevDeps };
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+    console.log(chalk.green("✓ Dépendances configurées"));
+}
+async function createNextStructure(targetDir, force, useHeroUI, withAuth) {
+    console.log(chalk.yellow("\n📁 Création de la structure Next.js..."));
+    const appDir = path.join(targetDir, "app");
+    const stylesDir = path.join(targetDir, "styles");
+    await fs.ensureDir(appDir);
+    await fs.ensureDir(stylesDir);
+    // Générer le layout principal
+    const layoutDest = path.join(appDir, "layout.tsx");
+    if (!fs.existsSync(layoutDest) || force) {
+        let layoutContent = "";
+        if (useHeroUI) {
+            // Layout avec HeroUI - Server Component
+            layoutContent = `// GENERATED BY LASTBRAIN APP-SHELL
+// Server Component pour permettre le SSR des pages enfants
+
+import "../styles/globals.css";
+import { ClientLayout } from "../components/ClientLayout";
+import type { PropsWithChildren } from "react";
+
+export default function RootLayout({ children }: PropsWithChildren<{}>) {
+  return (
+    <html lang="fr" suppressHydrationWarning>
+      <body className="min-h-screen">
+        <ClientLayout>{children}</ClientLayout>
+      </body>
+    </html>
+  );
+}
+`;
+        }
+        else {
+            // Layout Tailwind CSS uniquement - Server Component
+            layoutContent = `// GENERATED BY LASTBRAIN APP-SHELL
+// Server Component pour permettre le SSR des pages enfants
+
+import "../styles/globals.css";
+import { ClientLayout } from "../components/ClientLayout";
+import type { PropsWithChildren } from "react";
+
+export default function RootLayout({ children }: PropsWithChildren<{}>) {
+  return (
+    <html lang="fr" suppressHydrationWarning>
+      <body className="min-h-screen">
+        <ClientLayout>{children}</ClientLayout>
+      </body>
+    </html>
+  );
+}
+`;
+        }
+        await fs.writeFile(layoutDest, layoutContent);
+        console.log(chalk.green("✓ app/layout.tsx créé"));
+    }
+    else {
+        console.log(chalk.gray("  app/layout.tsx existe déjà (utilisez --force pour écraser)"));
+    }
+    // Créer globals.css
+    const globalsPath = path.join(stylesDir, "globals.css");
+    if (!fs.existsSync(globalsPath) || force) {
+        const globalsContent = `@import "tailwindcss";
+
+@config "../tailwind.config.mjs";
+`;
+        await fs.writeFile(globalsPath, globalsContent);
+        console.log(chalk.green("✓ styles/globals.css créé"));
+    }
+    // Créer la page d'accueil publique (racine)
+    const homePagePath = path.join(appDir, "page.tsx");
+    if (!fs.existsSync(homePagePath) || force) {
+        const homePageContent = `// GENERATED BY LASTBRAIN APP-SHELL
+
+import { SimpleHomePage } from "@lastbrain/app";
+import { Footer } from "@lastbrain/ui";
+import { footerConfig } from "../config/footer";
+
+export default function RootPage() {
+  return (
+    <>
+      <SimpleHomePage showAuth={${withAuth}} />
+      <Footer config={footerConfig} />
+    </>
+  );
+}
+`;
+        await fs.writeFile(homePagePath, homePageContent);
+        console.log(chalk.green("✓ app/page.tsx créé"));
+    }
+    // Créer la page not-found.tsx
+    const notFoundPath = path.join(appDir, "not-found.tsx");
+    if (!fs.existsSync(notFoundPath) || force) {
+        const notFoundContent = `"use client";
+import { Button } from "@lastbrain/ui";
+import { useRouter } from "next/navigation";
+
+export default function NotFound() {
+  const router = useRouter();
+  return (
+    <div className="flex min-h-screen items-center justify-center bg-background">
+      <div className="mx-auto max-w-md text-center">
+        <h1 className="mb-4 text-6xl font-bold text-foreground">404</h1>
+        <h2 className="mb-4 text-2xl font-semibold text-foreground">
+          Page non trouvée
+        </h2>
+        <p className="mb-8 text-muted-foreground">
+          La page que vous recherchez n'existe pas ou a été déplacée.
+        </p>
+        <Button
+          onPress={() => {
+            router.back();
+          }}
+          className="inline-flex items-center justify-center rounded-md bg-primary px-6 py-3 text-sm font-medium text-primary-foreground transition-colors hover:bg-primary/90"
+        >
+          Retour à l'accueil
+        </Button>
+      </div>
+    </div>
+  );
+}
+`;
+        await fs.writeFile(notFoundPath, notFoundContent);
+        console.log(chalk.green("✓ app/not-found.tsx créé"));
+    }
+    // Créer les routes avec leurs layouts
+    await createRoute(appDir, "admin", "admin", force);
+    await createRoute(appDir, "auth", "auth", force);
+    await createRoute(appDir, "docs", "public", force);
+    // Créer le composant ClientLayout (wrapper client avec providers)
+    await createClientLayout(targetDir, force, useHeroUI);
+    // Créer le composant AppHeader
+    await createAppHeader(targetDir, force);
+    // Créer le composant AppAside
+    await createAppAside(targetDir, force);
+    // Créer le wrapper AppProviders avec configuration realtime
+    await createAppProvidersWrapper(targetDir, force);
+}
+async function createClientLayout(targetDir, force, useHeroUI) {
+    const componentsDir = path.join(targetDir, "components");
+    await fs.ensureDir(componentsDir);
+    const clientLayoutPath = path.join(componentsDir, "ClientLayout.tsx");
+    if (!fs.existsSync(clientLayoutPath) || force) {
+        let clientLayoutContent = "";
+        if (useHeroUI) {
+            // ClientLayout avec HeroUI
+            clientLayoutContent = `"use client";
+
+import { HeroUIProvider } from "@heroui/system";
+import { ThemeProvider } from "next-themes";
+import { useRouter } from "next/navigation";
+import { AppProviders } from "./AppProviders";
+import { AppHeader } from "./AppHeader";
+import type { ReactNode } from "react";
+
+export function ClientLayout({ children }: { children: ReactNode }) {
+  const router = useRouter();
+
+  return (
+    <HeroUIProvider navigate={router.push}>
+      <ThemeProvider
+        attribute="class"
+        defaultTheme="dark"
+        enableSystem={false}
+        storageKey="lastbrain-theme"
+      >
+        <AppProviders>
+          <AppHeader />
+          <div className="min-h-screen text-foreground bg-background">
+            {children}
+          </div>
+        </AppProviders>
+      </ThemeProvider>
+    </HeroUIProvider>
+  );
+}
+`;
+        }
+        else {
+            // ClientLayout Tailwind CSS uniquement
+            clientLayoutContent = `"use client";
+
+import { ThemeProvider } from "next-themes";
+import { AppProviders } from "./AppProviders";
+import { AppHeader } from "./AppHeader";
+import type { ReactNode } from "react";
+
+export function ClientLayout({ children }: { children: ReactNode }) {
+  return (
+    <ThemeProvider
+      attribute="class"
+      defaultTheme="light"
+      enableSystem={false}
+      storageKey="lastbrain-theme"
+    >
+      <AppProviders>
+        <AppHeader />
+        <div className="min-h-screen bg-slate-50 text-slate-900 dark:bg-slate-950 dark:text-white">
+          {children}
+        </div>
+      </AppProviders>
+    </ThemeProvider>
+  );
+}
+`;
+        }
+        await fs.writeFile(clientLayoutPath, clientLayoutContent);
+        console.log(chalk.green("✓ components/ClientLayout.tsx créé"));
+    }
+    else {
+        console.log(chalk.gray("  components/ClientLayout.tsx existe déjà (utilisez --force pour écraser)"));
+    }
+}
+async function createRoute(appDir, routeName, layoutType, force) {
+    const routeDir = path.join(appDir, routeName);
+    await fs.ensureDir(routeDir);
+    // Layout pour la route
+    const layoutPath = path.join(routeDir, "layout.tsx");
+    if (!fs.existsSync(layoutPath) || force) {
+        let layoutContent = "";
+        if (routeName === "admin") {
+            // Layout admin avec sidebar
+            layoutContent = `import { AdminLayoutWithSidebar } from "@lastbrain/app";
+import { menuConfig } from "../../config/menu";
+
+export default function AdminLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <AdminLayoutWithSidebar menuConfig={menuConfig}>
+      {children}
+    </AdminLayoutWithSidebar>
+  );
+}`;
+        }
+        else if (routeName === "auth") {
+            // Layout auth avec sidebar
+            layoutContent = `import { AuthLayoutWithSidebar } from "@lastbrain/app";
+import { menuConfig } from "../../config/menu";
+
+export default function AuthLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <AuthLayoutWithSidebar menuConfig={menuConfig}>
+      {children}
+    </AuthLayoutWithSidebar>
+  );
+}`;
+        }
+        else {
+            // Layout standard pour les autres routes (ex: docs = public)
+            const layoutComponent = layoutType.charAt(0).toUpperCase() + layoutType.slice(1) + "Layout";
+            // Layout docs avec footer
+            layoutContent = `import { ${layoutComponent} } from "@lastbrain/app";
+import { footerConfig } from "../../config/footer";
+
+export default function DocsLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return <${layoutComponent} footerConfig={footerConfig}>{children}</${layoutComponent}>;
+}`;
+        }
+        await fs.writeFile(layoutPath, layoutContent);
+        console.log(chalk.green(`✓ app/${routeName}/layout.tsx créé`));
+    }
+    // Page par défaut
+    const pagePath = path.join(routeDir, "page.tsx");
+    if (!fs.existsSync(pagePath) || force) {
+        let templateImport = "";
+        let componentName = null;
+        // Choisir le template approprié selon la route
+        switch (routeName) {
+            case "admin":
+                templateImport = 'import { ModuleGuidePage } from "@lastbrain/app";';
+                componentName = "ModuleGuidePage";
+                break;
+            case "docs":
+                templateImport = 'import { SimpleDocPage } from "@lastbrain/app";';
+                componentName = "SimpleDocPage";
+                break;
+            default:
+                // Template générique pour les autres routes
+                templateImport = `// Generic page for ${routeName}`;
+                componentName = null;
+        }
+        const pageContent = componentName
+            ? `// GENERATED BY LASTBRAIN APP-SHELL
+
+${templateImport}
+
+export default function ${routeName.charAt(0).toUpperCase() + routeName.slice(1)}Page() {
+  return <${componentName} />;
+}
+`
+            : `// GENERATED BY LASTBRAIN APP-SHELL
+
+export default function ${routeName.charAt(0).toUpperCase() + routeName.slice(1)}Page() {
+  return (
+    <div className="container mx-auto px-4 py-8">
+      <h1 className="text-3xl font-bold mb-4">${routeName.charAt(0).toUpperCase() + routeName.slice(1)} Page</h1>
+      <p className="text-slate-600 dark:text-slate-400">
+        Cette page a été générée par LastBrain Init.
+      </p>
+      <p className="text-sm text-slate-500 dark:text-slate-500 mt-4">
+        Route: /${routeName}
+      </p>
+    </div>
+  );
+}
+`;
+        await fs.writeFile(pagePath, pageContent);
+        console.log(chalk.green(`✓ app/${routeName}/page.tsx créé`));
+    }
+}
+async function createAppHeader(targetDir, force) {
+    const componentsDir = path.join(targetDir, "components");
+    await fs.ensureDir(componentsDir);
+    const headerPath = path.join(componentsDir, "AppHeader.tsx");
+    if (!fs.existsSync(headerPath) || force) {
+        const headerContent = `"use client";
+
+import { Header, type MenuItem } from "@lastbrain/ui";
+import { menuConfig } from "../config/menu";
+import { supabaseBrowserClient } from "@lastbrain/core";
+import { useRouter } from "next/navigation";
+import { useAuthSession, useNotificationsContext } from "@lastbrain/app";
+import { useState, useEffect } from "react";
+
+interface MenuIgnored {
+  public: { title: string; path: string }[];
+  auth: { title: string; path: string }[];
+}
+
+export function AppHeader() {
+  const router = useRouter();
+  const { user, isSuperAdmin } = useAuthSession();
+  const { data, loading, markAsRead, markAllAsRead, deleteNotification } =
+    useNotificationsContext();
+  const [menuIgnored, setMenuIgnored] = useState<MenuIgnored | undefined>();
+  const [menuCustom, setMenuCustom] = useState<MenuItem[] | undefined>();
+  const [isLoading, setIsLoading] = useState(true);
+
+  // Charger menuIgnored et menuCustom s'ils existent
+  useEffect(() => {
+    let loadedIgnored = false;
+    let loadedCustom = false;
+
+    // Charger menu-ignored
+    import("../config/menu-ignored")
+      .then((mod) => setMenuIgnored(mod.menuIgnored))
+      .catch(() => setMenuIgnored(undefined))
+      .finally(() => {
+        loadedIgnored = true;
+        if (loadedIgnored && loadedCustom) setIsLoading(false);
+      });
+
+    // Charger menu-custom
+    import("../config/menu-custom")
+      .then((mod) => {
+        // Combiner les menus custom publics et auth
+        const customMenus: MenuItem[] = [];
+        if (mod.menuCustom?.public) customMenus.push(...mod.menuCustom.public);
+        if (mod.menuCustom?.auth) customMenus.push(...mod.menuCustom.auth);
+        setMenuCustom(customMenus.length > 0 ? customMenus : undefined);
+      })
+      .catch(() => setMenuCustom(undefined))
+      .finally(() => {
+        loadedCustom = true;
+        if (loadedIgnored && loadedCustom) setIsLoading(false);
+      });
+  }, []);
+
+  const handleLogout = async () => {
+    await supabaseBrowserClient.auth.signOut();
+    router.push("/");
+    router.refresh();
+  };
+
+  return (
+    <Header
+      user={user}
+      onLogout={handleLogout}
+      menuConfig={menuConfig}
+      accountMenu={menuConfig.account}
+      brandName="LastBrain App"
+      brandHref="/"
+      isSuperAdmin={isSuperAdmin}
+      notifications={data.notifications}
+      unreadCount={data.unreadCount}
+      notificationsLoading={loading}
+      onMarkAsRead={markAsRead}
+      onMarkAllAsRead={markAllAsRead}
+      onDeleteNotification={deleteNotification}
+      {...(menuIgnored ? { menuIgnored } : {})}
+      {...(menuCustom ? { menuCustom } : {})}
+      {...{ isLoadingMenus: isLoading }}
+    />
+  );
+}
+`;
+        await fs.writeFile(headerPath, headerContent);
+        console.log(chalk.green("✓ components/AppHeader.tsx créé"));
+    }
+    else {
+        console.log(chalk.gray("  components/AppHeader.tsx existe déjà (utilisez --force pour écraser)"));
+    }
+}
+async function createAppAside(targetDir, force) {
+    const componentsDir = path.join(targetDir, "components");
+    await fs.ensureDir(componentsDir);
+    const asidePath = path.join(componentsDir, "AppAside.tsx");
+    if (!fs.existsSync(asidePath) || force) {
+        const asideContent = `"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}
+    />
+  );
+}`;
+        await fs.writeFile(asidePath, asideContent);
+        console.log(chalk.green("✓ components/AppAside.tsx créé"));
+    }
+    else {
+        console.log(chalk.gray("  components/AppAside.tsx existe déjà (utilisez --force pour écraser)"));
+    }
+}
+async function createAppProvidersWrapper(targetDir, force) {
+    const componentsDir = path.join(targetDir, "components");
+    await fs.ensureDir(componentsDir);
+    const providersPath = path.join(componentsDir, "AppProviders.tsx");
+    if (!fs.existsSync(providersPath) || force) {
+        const providersContent = `"use client";
+
+import { AppProviders as BaseAppProviders } from "@lastbrain/app";
+import { realtimeConfig } from "../config/realtime";
+import type { ReactNode } from "react";
+
+export function AppProviders({ children }: { children: ReactNode }) {
+  return (
+    <BaseAppProviders realtimeConfig={realtimeConfig}>
+      {children}
+    </BaseAppProviders>
+  );
+}`;
+        await fs.writeFile(providersPath, providersContent);
+        console.log(chalk.green("✓ components/AppProviders.tsx créé"));
+    }
+    else {
+        console.log(chalk.gray("  components/AppProviders.tsx existe déjà (utilisez --force pour écraser)"));
+    }
+}
+async function createConfigFiles(targetDir, force, useHeroUI, projectName) {
+    console.log(chalk.yellow("\n⚙️  Création des fichiers de configuration..."));
+    // middleware.ts - Protection des routes /auth/*, /admin/* et /api/admin/*
+    const middlewarePath = path.join(targetDir, "middleware.ts");
+    if (!fs.existsSync(middlewarePath) || force) {
+        const middleware = `import { type NextRequest, NextResponse } from "next/server";
+import { createServerClient, type CookieOptions } from "@supabase/ssr";
+
+/**
+ * Crée un client Supabase pour le middleware
+ */
+function createMiddlewareClient(request: NextRequest) {
+  let response = NextResponse.next({
+    request: {
+      headers: request.headers,
+    },
+  });
+
+  const supabase = createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+    {
+      cookies: {
+        get(name: string) {
+          return request.cookies.get(name)?.value;
+        },
+        set(name: string, value: string, options: CookieOptions) {
+          request.cookies.set({
+            name,
+            value,
+            ...options,
+          });
+          response = NextResponse.next({
+            request: {
+              headers: request.headers,
+            },
+          });
+          response.cookies.set({
+            name,
+            value,
+            ...options,
+          });
+        },
+        remove(name: string, options: CookieOptions) {
+          request.cookies.delete(name);
+          response = NextResponse.next({
+            request: {
+              headers: request.headers,
+            },
+          });
+          response.cookies.delete(name);
+        },
+      },
+    }
+  );
+
+  return { supabase, response };
+}
+
+export async function middleware(request: NextRequest) {
+  const { pathname } = request.nextUrl;
+  const isApi = pathname.startsWith("/api/");
+
+  // Pages publiques d'authentification (ne pas protéger)
+  const publicAuthPages = [
+    "/signin",
+    "/signup",
+    "/reset-password",
+    "/forgot-password",
+    "/callback",
+  ];
+
+  if(process.env.MAINTENANCE_MODE === "true" && !pathname.startsWith("/maintenance")) {
+    const redirectUrl = new URL("/maintenance", request.url);
+    return NextResponse.redirect(redirectUrl);
+  }
+
+  const isPublicAuthPage = publicAuthPages.some((page) =>
+    pathname.startsWith(page)
+  );
+
+  // Ne pas protéger les pages publiques d'authentification
+  if (isPublicAuthPage) {
+    return NextResponse.next();
+  }
+
+  // Protéger les routes /auth/* (espace membre)
+  if (pathname.startsWith("/auth")) {
+    try {
+      const { supabase, response } = createMiddlewareClient(request);
+      const {
+        data: { session },
+      } = await supabase.auth.getSession();
+
+      // Pas de session → nettoyage des cookies + redirection vers /signin
+      if (!session) {
+        const redirectUrl = new URL("/signin", request.url);
+        redirectUrl.searchParams.set("redirect", pathname);
+        const res = NextResponse.redirect(redirectUrl);
+        res.cookies.delete("sb-access-token");
+        res.cookies.delete("sb-refresh-token");
+        res.cookies.delete("sb:token");
+        res.cookies.delete("sb:refresh-token");
+        return res;
+      }
+
+      return response;
+    } catch (error) {
+      console.error("Middleware auth error:", error);
+      const res = NextResponse.redirect(new URL("/signin", request.url));
+      res.cookies.delete("sb-access-token");
+      res.cookies.delete("sb-refresh-token");
+      res.cookies.delete("sb:token");
+      res.cookies.delete("sb:refresh-token");
+      return res;
+    }
+  }
+
+  // Protéger les routes /admin/* et /api/admin/* (superadmin uniquement)
+  if (pathname.startsWith("/admin") || pathname.startsWith("/api/admin")) {
+    try {
+      const { supabase, response } = createMiddlewareClient(request);
+      const {
+        data: { session },
+      } = await supabase.auth.getSession();
+
+      // Pas de session → 401 JSON pour API, sinon redirection vers /signin avec nettoyage cookies
+      if (!session) {
+        if (isApi) {
+          const res = NextResponse.json({ error: "Non authentifié" }, { status: 401 });
+          res.cookies.delete("sb-access-token");
+          res.cookies.delete("sb-refresh-token");
+          res.cookies.delete("sb:token");
+          res.cookies.delete("sb:refresh-token");
+          return res;
+        }
+        const redirectUrl = new URL("/signin", request.url);
+        redirectUrl.searchParams.set("redirect", pathname);
+        const res = NextResponse.redirect(redirectUrl);
+        res.cookies.delete("sb-access-token");
+        res.cookies.delete("sb-refresh-token");
+        res.cookies.delete("sb:token");
+        res.cookies.delete("sb:refresh-token");
+        return res;
+      }
+
+      // Vérifier si l'utilisateur est superadmin
+      const { data: isSuperAdmin, error } = await supabase.rpc(
+        "is_superadmin",
+        { user_id: session.user.id }
+      );
+
+      if (error || !isSuperAdmin) {
+        console.error("Access denied: not a superadmin", error);
+        if (isApi) {
+          return NextResponse.json({ error: "Accès refusé" }, { status: 403 });
+        }
+        return NextResponse.redirect(new URL("/", request.url));
+      }
+
+      return response;
+    } catch (error) {
+      console.error("Middleware admin error:", error);
+      if (isApi) {
+        return NextResponse.json({ error: "Erreur middleware" }, { status: 500 });
+      }
+      const res = NextResponse.redirect(new URL("/", request.url));
+      res.cookies.delete("sb-access-token");
+      res.cookies.delete("sb-refresh-token");
+      res.cookies.delete("sb:token");
+      res.cookies.delete("sb:refresh-token");
+      return res;
+    }
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: [
+    /*
+     * Match all request paths except:
+     * - _next/static (static files)
+     * - _next/image (image optimization files)
+     * - favicon.ico (favicon file)
+     * - public folder
+     */
+    "/((?!_next/static|_next/image|favicon.ico|.*\\\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)",
+  ],
+};
+`;
+        await fs.writeFile(middlewarePath, middleware);
+        console.log(chalk.green("✓ middleware.ts créé (protection /auth/*, /admin/* et /api/admin/*)"));
+    }
+    // next.config.mjs
+    const nextConfigPath = path.join(targetDir, "next.config.mjs");
+    if (!fs.existsSync(nextConfigPath) || force) {
+        const nextConfig = `/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+  devIndicators: {
+    position: 'bottom-right',
+  }
+};
+
+export default nextConfig;
+`;
+        await fs.writeFile(nextConfigPath, nextConfig);
+        console.log(chalk.green("✓ next.config.mjs créé"));
+    }
+    // tailwind.config.mjs
+    const tailwindConfigPath = path.join(targetDir, "tailwind.config.mjs");
+    if (!fs.existsSync(tailwindConfigPath) || force) {
+        let tailwindConfig = "";
+        if (useHeroUI) {
+            // Configuration avec HeroUI - complète avec thèmes
+            tailwindConfig = `import { heroui } from "@heroui/theme";
+
+/** @type {import('tailwindcss').Config} */
+const config = {
+  content: [
+    "./app/**/*.{js,ts,jsx,tsx,mdx}",
+    "./components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./node_modules/@lastbrain/*/src/**/*.{js,jsx,ts,tsx}",
+    "./node_modules/@heroui/theme/dist/**/*.{js,mjs}",
+  ],
+  darkMode: "class",
+  plugins: [
+    heroui({
+      themes: {
+        light: {
+          colors: {
+            default: {
+              950: "#0d0d0e",
+              900: "#19191c",
+              800: "#26262a",
+              700: "#323238",
+              600: "#3f3f46",
+              500: "#65656b",
+              400: "#8c8c90",
+              300: "#b2b2b5",
+              200: "#d9d9da",
+              100: "#ffffff",
+              foreground: "#000000",
+              DEFAULT: "#d4d4d8",
+            },
+            primary: {
+              50: "#eef2ff",
+              100: "#e0e7ff",
+              200: "#c7d2fe",
+              300: "#a5b4fc",
+              400: "#818cf8",
+              500: "#6366f1",
+              600: "#4f46e5",
+              700: "#4338ca",
+              800: "#3730a3",
+              900: "#312e81",
+              foreground: "#ffffff",
+              DEFAULT: "#6366f1",
+            },
+            secondary: {
+              50: "#f5e8ff",
+              100: "#e8ccff",
+              200: "#d7a6ff",
+              300: "#c57fff",
+              400: "#b359ff",
+              500: "#9b37ff",
+              600: "#7d1fcc",
+              700: "#5f1799",
+              800: "#410f66",
+              900: "#240833",
+              foreground: "#ffffff",
+              DEFAULT: "#9b37ff",
+            },
+            success: {
+              50: "#e7fff7",
+              100: "#c3ffec",
+              200: "#9affdf",
+              300: "#70ffd2",
+              400: "#4bffca",
+              500: "#22e6b0",
+              600: "#18b38a",
+              700: "#108066",
+              800: "#074d40",
+              900: "#012b22",
+              foreground: "#000",
+              DEFAULT: "#22e6b0",
+            },
+            warning: {
+              50: "#fff8e1",
+              100: "#ffecb3",
+              200: "#ffe082",
+              300: "#ffd54f",
+              400: "#ffca28",
+              500: "#ffc107",
+              600: "#ffb300",
+              700: "#ffa000",
+              800: "#ff8f00",
+              900: "#ff6f00",
+              foreground: "#000",
+              DEFAULT: "#ffca28",
+            },
+            danger: {
+              50: "#ffe6e9",
+              100: "#ffbac1",
+              200: "#ff8f99",
+              300: "#ff6471",
+              400: "#ff3949",
+              500: "#ff112a",
+              600: "#d80c22",
+              700: "#b1081b",
+              800: "#890514",
+              900: "#62020d",
+              foreground: "#fff",
+              DEFAULT: "#ff112a",
+            },
+            background: "#f7f8fc",
+            foreground: "#0e0e10",
+            content1: "#ffffff",
+          },
+        },
+        dark: {
+          colors: {
+            default: {
+              50: "#1a1c1f",
+              100: "#232529",
+              200: "#2c2f34",
+              300: "#363940",
+              400: "#40444d",
+              500: "#4b4f59",
+              600: "#6c707b",
+              700: "#8d919b",
+              800: "#afb2bb",
+              900: "#d1d3d9",
+              foreground: "#ffffff",
+              DEFAULT: "#363940",
+            },
+            primary: {
+              50: "#312e81",
+              100: "#3730a3",
+              200: "#4338ca",
+              300: "#4f46e5",
+              400: "#6366f1",
+              500: "#818cf8",
+              600: "#a5b4fc",
+              700: "#c7d2fe",
+              800: "#e0e7ff",
+              900: "#eef2ff",
+              foreground: "#ffffff",
+              DEFAULT: "#6366f1",
+            },
+            secondary: {
+              50: "#240833",
+              100: "#410f66",
+              200: "#5f1799",
+              300: "#7d1fcc",
+              400: "#9b37ff",
+              500: "#b359ff",
+              600: "#c57fff",
+              700: "#d7a6ff",
+              800: "#e8ccff",
+              900: "#f5e8ff",
+              foreground: "#ffffff",
+              DEFAULT: "#9b37ff",
+            },
+            success: {
+              50: "#012b22",
+              100: "#074d40",
+              200: "#108066",
+              300: "#18b38a",
+              400: "#22e6b0",
+              500: "#4bffca",
+              600: "#70ffd2",
+              700: "#9affdf",
+              800: "#c3ffec",
+              900: "#e7fff7",
+              foreground: "#0e0e0e",
+              DEFAULT: "#22e6b0",
+            },
+            warning: {
+              50: "#3a2c00",
+              100: "#5e4700",
+              200: "#836300",
+              300: "#a77e00",
+              400: "#cc9900",
+              500: "#ffc107",
+              600: "#ffd54f",
+              700: "#ffe082",
+              800: "#ffecb3",
+              900: "#fff8e1",
+              foreground: "#000",
+              DEFAULT: "#ffc107",
+            },
+            danger: {
+              50: "#4a000a",
+              100: "#6e000f",
+              200: "#920014",
+              300: "#b60019",
+              400: "#da001f",
+              500: "#ff112a",
+              600: "#ff3949",
+              700: "#ff6471",
+              800: "#ff8f99",
+              900: "#ffbac1",
+              foreground: "#ffffff",
+              DEFAULT: "#ff112a",
+            },
+            background: "#0f1114",
+            foreground: "#f8f8f8",
+            content1: "#15181d",
+          },
+        },
+      },
+    }),
+  ],
+};
+
+export default config;
+`;
+        }
+        else {
+            // Configuration Tailwind CSS uniquement
+            tailwindConfig = `/** @type {import('tailwindcss').Config} */
+const config = {
+  content: [
+    "./app/**/*.{js,ts,jsx,tsx,mdx}",
+    "./components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./node_modules/@lastbrain/*/src/**/*.{js,jsx,ts,tsx}",
+  ],
+  theme: {
+    extend: {
+      colors: {
+        primary: {
+          50: "#eff6ff",
+          100: "#dbeafe",
+          200: "#bfdbfe",
+          300: "#93c5fd",
+          400: "#60a5fa",
+          500: "#3b82f6",
+          600: "#2563eb",
+          700: "#1d4ed8",
+          800: "#1e40af",
+          900: "#1e3a8a",
+          950: "#172554",
+        },
+      },
+    },
+  },
+  plugins: [],
+}
+
+export default config;
+`;
+        }
+        await fs.writeFile(tailwindConfigPath, tailwindConfig);
+        console.log(chalk.green("✓ tailwind.config.mjs créé"));
+    }
+    // postcss.config.mjs
+    const postcssConfigPath = path.join(targetDir, "postcss.config.mjs");
+    if (!fs.existsSync(postcssConfigPath) || force) {
+        const postcssConfig = `export default {
+  plugins: {
+    '@tailwindcss/postcss': {},
+  },
+};
+`;
+        await fs.writeFile(postcssConfigPath, postcssConfig);
+        console.log(chalk.green("✓ postcss.config.mjs créé"));
+    }
+    // tsconfig.json
+    const tsconfigPath = path.join(targetDir, "tsconfig.json");
+    if (!fs.existsSync(tsconfigPath) || force) {
+        // Détecter si le projet cible est dans un monorepo
+        const targetIsInMonorepo = fs.existsSync(path.join(targetDir, "../../../packages/core/package.json")) ||
+            fs.existsSync(path.join(targetDir, "../../packages/core/package.json"));
+        // Générer les chemins en fonction du contexte
+        const paths = {
+            "@/*": ["./*"],
+        };
+        if (targetIsInMonorepo) {
+            // En monorepo, pointer sur les sources locales
+            paths["@lastbrain/ui"] = ["../../packages/ui/src/index.ts"];
+            paths["@lastbrain/ui/*"] = ["../../packages/ui/src/*"];
+            paths["@lastbrain/core"] = ["../../packages/core/src/index.ts"];
+            paths["@lastbrain/core/*"] = ["../../packages/core/src/*"];
+            paths["@lastbrain/app"] = ["../../packages/app/src/index.ts"];
+            paths["@lastbrain/app/*"] = ["../../packages/app/src/*"];
+            paths["@lastbrain/module-auth"] = [
+                "../../packages/module-auth/src/index.ts",
+            ];
+            paths["@lastbrain/module-auth/*"] = ["../../packages/module-auth/src/*"];
+            paths["@lastbrain/module-ai"] = ["../../packages/module-ai/src/index.ts"];
+            paths["@lastbrain/module-ai/*"] = ["../../packages/module-ai/src/*"];
+            paths["@lastbrain/module-legal"] = [
+                "../../packages/module-legal/src/index.ts",
+            ];
+            paths["@lastbrain/module-legal/*"] = [
+                "../../packages/module-legal/src/*",
+            ];
+            paths["@lastbrain/module-project-board"] = [
+                "../../packages/module-project-board/src/index.ts",
+            ];
+            paths["@lastbrain/module-project-board/*"] = [
+                "../../packages/module-project-board/src/*",
+            ];
+            paths["@lastbrain/module-tasks"] = [
+                "../../packages/module-tasks/src/index.ts",
+            ];
+            paths["@lastbrain/module-tasks/*"] = [
+                "../../packages/module-tasks/src/*",
+            ];
+        }
+        else {
+            // Hors monorepo (npm install), ne pas utiliser de paths aliases
+            delete paths["@/*"];
+        }
+        const tsconfig = {
+            compilerOptions: {
+                target: "ES2020",
+                lib: ["ES2020", "DOM", "DOM.Iterable"],
+                jsx: "preserve",
+                module: "ESNext",
+                moduleResolution: "bundler",
+                resolveJsonModule: true,
+                allowJs: true,
+                strict: true,
+                noEmit: true,
+                esModuleInterop: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                incremental: true,
+                isolatedModules: true,
+                plugins: [{ name: "next" }],
+                paths,
+                types: [],
+            },
+            include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+            exclude: ["node_modules", "dist", ".next", "out"],
+        };
+        // Ajouter extends seulement en monorepo
+        if (targetIsInMonorepo) {
+            tsconfig.extends = "../../tsconfig.base.json";
+        }
+        await fs.writeJson(tsconfigPath, tsconfig, { spaces: 2 });
+        console.log(chalk.green("✓ tsconfig.json créé"));
+    }
+    // config/menu.ts
+    const configDir = path.join(targetDir, "config");
+    await fs.ensureDir(configDir);
+    const menuConfigPath = path.join(configDir, "menu.ts");
+    if (!fs.existsSync(menuConfigPath) || force) {
+        const menuConfig = `import type { MenuConfig } from "@lastbrain/ui";
+
+export const menuConfig: MenuConfig = {
+  public: [
+    { label: "Accueil", href: "/" },
+    { label: "Documentation", href: "/docs" },
+  ],
+  auth: [
+    { label: "Dashboard", href: "/auth/dashboard" },
+    { label: "Profil", href: "/auth/profile" },
+  ],
+  admin: [
+    { label: "Admin", href: "/admin" },
+    { label: "Utilisateurs", href: "/admin/users" },
+  ],
+};
+`;
+        await fs.writeFile(menuConfigPath, menuConfig);
+        console.log(chalk.green("✓ config/menu.ts créé"));
+    }
+    // config/menu-ignored.ts - Optional file to hide menus and block routes
+    const menuIgnoredPath = path.join(configDir, "menu-ignored.ts");
+    if (!fs.existsSync(menuIgnoredPath) || force) {
+        const menuIgnored = `import type { MenuIgnored } from "@lastbrain/app";
+
+/**
+ * Menu items to hide and routes to block
+ * This file is optional - if it doesn't exist, all menus are shown
+ * 
+ * Example:
+ * export const menuIgnored: MenuIgnored = {
+ *   public: [
+ *     { title: "Documentation", path: "/docs" }
+ *   ],
+ *   auth: [
+ *     { title: "Profile", path: "/auth/profile" }
+ *   ]
+ * };
+ */
+
+export const menuIgnored: MenuIgnored = {
+  public: [],
+  auth: [],
+};
+`;
+        await fs.writeFile(menuIgnoredPath, menuIgnored);
+        console.log(chalk.green("✓ config/menu-ignored.ts créé"));
+    }
+    // config/menu-custom.ts - Optional file to add custom menus
+    const menuCustomPath = path.join(configDir, "menu-custom.ts");
+    if (!fs.existsSync(menuCustomPath) || force) {
+        const menuCustom = `import type { MenuCustom } from "@lastbrain/app";
+
+/**
+ * Custom menu items to add without creating a module
+ * This file is optional - if it doesn't exist, no custom menus are added
+ * 
+ * Example:
+ * export const menuCustom: MenuCustom = {
+ *   public: [
+ *     { label: "Blog", href: "/blog" },
+ *     { label: "Pricing", href: "/pricing" }
+ *   ],
+ *   auth: [
+ *     { label: "Invoices", href: "/auth/invoices" }
+ *   ],
+ *   admin: [
+ *     { label: "Reports", href: "/admin/reports" }
+ *   ]
+ * };
+ */
+
+export const menuCustom: MenuCustom = {
+  public: [],
+  auth: [],
+  admin: [],
+};
+`;
+        await fs.writeFile(menuCustomPath, menuCustom);
+        console.log(chalk.green("✓ config/menu-custom.ts créé"));
+    }
+    // config/footer.ts
+    const footerConfigPath = path.join(configDir, "footer.ts");
+    if (!fs.existsSync(footerConfigPath) || force) {
+        const footerConfig = `// Auto-generated footer configuration
+// Run "node ../../scripts/generate-footer-config.js ./apps/[your-app]" to regenerate
+"use client";
+
+import type { FooterConfig } from "@lastbrain/ui";
+
+export const footerConfig: FooterConfig = {
+  companyName: "${projectName}",
+  companyDescription: "Application LastBrain",
+  links: [],
+  social: [],
+};
+`;
+        await fs.writeFile(footerConfigPath, footerConfig);
+        console.log(chalk.green("✓ config/footer.ts créé"));
+    }
+    // config/user-tabs.ts - User detail page tabs configuration
+    const userTabsConfigPath = path.join(configDir, "user-tabs.ts");
+    if (!fs.existsSync(userTabsConfigPath) || force) {
+        const userTabsConfig = `// User tabs configuration
+// This file is generated and can be regenerated by running: pnpm build:modules
+"use client";
+
+import type React from "react";
+
+export interface ModuleUserTab {
+  id: string;
+  label: string;
+  component: React.ComponentType<{ userId: string }>;
+}
+
+// Module user tabs - dynamically imported from active modules
+// To add tabs from modules, import them here and add to the array below
+export const moduleUserTabs: ModuleUserTab[] = [];
+`;
+        await fs.writeFile(userTabsConfigPath, userTabsConfig);
+        console.log(chalk.green("✓ config/user-tabs.ts créé"));
+    }
+    // Créer les hooks
+    await createHooksDirectory(targetDir, force);
+}
+async function createHooksDirectory(targetDir, force) {
+    const hooksDir = path.join(targetDir, "hooks");
+    await fs.ensureDir(hooksDir);
+    // Créer le hook useNotifications
+    const useNotificationsPath = path.join(hooksDir, "useNotifications.ts");
+    if (!fs.existsSync(useNotificationsPath) || force) {
+        const hookContent = `"use client";
+
+import { useEffect, useState } from "react";
+import { useNotificationRealtime } from "@lastbrain/core";
+import { supabaseBrowserClient } from "@lastbrain/core";
+import { useAuth } from "@lastbrain/app";
+
+export interface Notification {
+  id: string;
+  title: string;
+  message: string;
+  read: boolean;
+  created_at: string;
+  owner_id: string;
+}
+
+export function useNotifications() {
+  const { user } = useAuth();
+  const [notifications, setNotifications] = useState<Notification[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+  
+  // Écouter les changements en temps réel
+  const realtimeSignal = useNotificationRealtime();
+
+  // Charger les notifications initiales
+  const fetchNotifications = async () => {
+    if (!user?.id) return;
+
+    try {
+      setLoading(true);
+      const { data, error } = await supabaseBrowserClient
+        .from("user_notifications")
+        .select("*")
+        .eq("owner_id", user.id)
+        .order("created_at", { ascending: false });
+
+      if (error) throw error;
+      setNotifications(data || []);
+      setError(null);
+    } catch (err) {
+      setError(err as Error);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  // Charger au montage et quand l'utilisateur change
+  useEffect(() => {
+    fetchNotifications();
+  }, [user?.id]);
+
+  // Recharger quand les données changent en temps réel
+  useEffect(() => {
+    if (realtimeSignal.hasUpdates && user?.id) {
+      console.log("🔔 Rechargement des notifications suite à un changement");
+      fetchNotifications();
+    }
+  }, [realtimeSignal.tick, user?.id]);
+
+  return {
+    notifications,
+    loading,
+    error,
+    refetch: fetchNotifications,
+    hasUpdates: realtimeSignal.hasUpdates,
+  };
+}
+`;
+        await fs.writeFile(useNotificationsPath, hookContent);
+        console.log(chalk.green("✓ hooks/useNotifications.ts créé"));
+    }
+    // Créer un placeholder pour realtime.ts qui sera généré par build:modules
+    const realtimePath = path.join(targetDir, "config", "realtime.ts");
+    if (!fs.existsSync(realtimePath) || force) {
+        const realtimeContent = `import type { ModuleRealtimeConfig } from "@lastbrain/core";
+
+// GENERATED FILE - DO NOT EDIT MANUALLY
+// Ce fichier sera automatiquement généré lors du build:modules
+// Exécutez "pnpm build:modules" pour créer la configuration realtime
+
+export const realtimeConfig: ModuleRealtimeConfig[] = [];
+
+export default realtimeConfig;
+`;
+        await fs.writeFile(realtimePath, realtimeContent);
+        console.log(chalk.green("✓ config/realtime.ts placeholder créé"));
+    }
+}
+async function createGitIgnore(targetDir, force) {
+    const gitignorePath = path.join(targetDir, ".gitignore");
+    if (!fs.existsSync(gitignorePath) || force) {
+        console.log(chalk.yellow("\n📝 Création de .gitignore..."));
+        // Copier le fichier .gitignore depuis le template
+        const templateGitignorePath = path.join(__dirname, "../templates/gitignore/.gitignore");
+        if (fs.existsSync(templateGitignorePath)) {
+            await fs.copyFile(templateGitignorePath, gitignorePath);
+        }
+        else {
+            // Fallback si le template n'existe pas
+            const gitignoreContent = `# ===========================================
+# GENERATED BY LASTBRAIN
+# ===========================================
+
+# Node
+node_modules/
+npm-debug.log*
+pnpm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Environment
+.env
+.env.*
+!.env.example
+
+# Next.js
+.next/
+out/
+dist/
+build/
+
+# Supabase
+supabase/.temp/
+supabase/functions/.netlify/
+supabase/functions/node_modules/
+supabase/.branches/
+
+# Logs
+logs
+*.log
+*.log.*
+
+# OS / Editor
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/
+*.swp
+
+# Local backups
+*.sql
+*.sql.zip
+backup/
+tmp/
+
+# Coverage
+coverage/
+*.lcov
+
+
+`;
+            await fs.writeFile(gitignorePath, gitignoreContent);
+        }
+        console.log(chalk.green("✓ .gitignore créé"));
+    }
+}
+async function createEnvExample(targetDir, force) {
+    const envExamplePath = path.join(targetDir, ".env.local.example");
+    if (!fs.existsSync(envExamplePath) || force) {
+        console.log(chalk.yellow("\n🔐 Création de .env.local.example..."));
+        const envContent = `# Supabase Configuration
+# Exécutez 'pnpm db:init' pour initialiser Supabase local et générer le vrai .env.local
+
+# Supabase Local (par défaut)
+NEXT_PUBLIC_SUPABASE_URL=http://127.0.0.1:54321
+NEXT_PUBLIC_SUPABASE_ANON_KEY=YOUR_LOCAL_ANON_KEY
+SUPABASE_SERVICE_ROLE_KEY=YOUR_LOCAL_SERVICE_ROLE_KEY
+
+# Supabase Production
+# NEXT_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
+# NEXT_PUBLIC_SUPABASE_ANON_KEY=your_production_anon_key
+# SUPABASE_SERVICE_ROLE_KEY=your_production_service_role_key
+`;
+        await fs.writeFile(envExamplePath, envContent);
+        console.log(chalk.green("✓ .env.local.example créé"));
+    }
+}
+async function createEnvLocal(targetDir, force, isMonorepoProject = false) {
+    const envLocalPath = path.join(targetDir, ".env.local");
+    if (!fs.existsSync(envLocalPath) || force) {
+        console.log(chalk.yellow("\n🔐 Création de .env.local..."));
+        let envContent;
+        if (isMonorepoProject) {
+            // Pour les projets monorepo, utiliser les variables du monorepo
+            envContent = `# Supabase Configuration (Monorepo - Centralisé)
+# Les variables Supabase sont gérées au niveau du monorepo
+
+# OpenAI Configuration (clé factice pour éviter les erreurs de build)
+OPENAI_API_KEY=sk-fake-openai-key-for-development-replace-with-real-key
+
+# Note: Les variables Supabase sont fournies par le monorepo parent
+`;
+        }
+        else {
+            // Pour les projets indépendants
+            envContent = `# Supabase Configuration
+# Valeurs par défaut pour le développement local
+
+# Supabase Local (par défaut)
+NEXT_PUBLIC_SUPABASE_URL=http://127.0.0.1:54321
+NEXT_PUBLIC_SUPABASE_ANON_KEY=eyJhbGc...
+SUPABASE_SERVICE_ROLE_KEY=eyJhbGc...
+
+# OpenAI Configuration (clé factice pour éviter les erreurs de build)
+OPENAI_API_KEY=sk-fake-openai-key-for-development-replace-with-real-key
+`;
+        }
+        await fs.writeFile(envLocalPath, envContent);
+        console.log(chalk.green("✓ .env.local créé"));
+    }
+}
+async function createEnvProd(targetDir, force) {
+    const envProdPath = path.join(targetDir, ".env.prod");
+    if (!fs.existsSync(envProdPath) || force) {
+        console.log(chalk.yellow("\n🔐 Création de .env.prod..."));
+        const envContent = `# Production Environment Configuration
+# Copy your production values here
+
+# Supabase Production
+NEXT_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
+NEXT_PUBLIC_SUPABASE_ANON_KEY=your-prod-anon-key
+SUPABASE_SERVICE_ROLE_KEY=your-prod-service-role-key
+
+# OpenAI Production
+OPENAI_API_KEY=sk-proj-your-prod-api-key
+
+# Note: Update these values with your actual production credentials
+`;
+        await fs.writeFile(envProdPath, envContent);
+        console.log(chalk.green("✓ .env.prod créé"));
+    }
+}
+async function createSupabaseStructure(targetDir, force) {
+    console.log(chalk.yellow("\n🗄️  Création de la structure Supabase..."));
+    const supabaseDir = path.join(targetDir, "supabase");
+    const migrationsDir = path.join(supabaseDir, "migrations");
+    await fs.ensureDir(migrationsDir);
+    // Copier le fichier de migration initial depuis le template
+    const templateMigrationPath = path.join(__dirname, "../templates/migrations/20201010100000_app_base.sql");
+    const migrationDestPath = path.join(migrationsDir, "20201010100000_app_base.sql");
+    if (!fs.existsSync(migrationDestPath) || force) {
+        try {
+            if (fs.existsSync(templateMigrationPath)) {
+                await fs.copy(templateMigrationPath, migrationDestPath);
+                console.log(chalk.green("✓ supabase/migrations/20201010100000_app_base.sql créé"));
+            }
+            else {
+                console.log(chalk.yellow("⚠ Template de migration introuvable, création d'un fichier vide"));
+                await fs.writeFile(migrationDestPath, "-- Initial migration\n-- Add your database schema here\n");
+                console.log(chalk.green("✓ supabase/migrations/20201010100000_app_base.sql créé (vide)"));
+            }
+        }
+        catch (_error) {
+            console.error(chalk.red("✗ Erreur lors de la création de la migration:"), _error);
+        }
+    }
+    else {
+        console.log(chalk.gray("  supabase/migrations/20201010100000_app_base.sql existe déjà"));
+    }
+}
+async function addScriptsToPackageJson(targetDir) {
+    console.log(chalk.yellow("\n🔧 Ajout des scripts NPM..."));
+    const pkgPath = path.join(targetDir, "package.json");
+    const pkg = await fs.readJson(pkgPath);
+    // Détecter si le projet cible est dans un workspace
+    const targetIsInMonorepo = fs.existsSync(path.join(targetDir, "../../../packages/core/package.json")) ||
+        fs.existsSync(path.join(targetDir, "../../packages/core/package.json"));
+    // Utiliser le CLI depuis le monorepo si présent, sinon depuis node_modules
+    const scriptsPrefix = targetIsInMonorepo
+        ? "node ../../packages/app/dist/cli.js"
+        : "node node_modules/@lastbrain/app/dist/cli.js";
+    const scripts = {
+        predev: targetIsInMonorepo
+            ? "pnpm --filter @lastbrain/core build && pnpm --filter @lastbrain/ui build && pnpm --filter @lastbrain/app build && pnpm --filter @lastbrain/module-auth build && pnpm --filter @lastbrain/module-ai build"
+            : "echo 'No prebuild needed'",
+        dev: "next dev",
+        "dev:local": "env-cmd -f .env.local next dev",
+        "dev:prod": "env-cmd -f .env.prod next dev",
+        build: "next build",
+        start: "next start",
+        lint: "next lint",
+        lastbrain: scriptsPrefix,
+        "build:modules": `${scriptsPrefix} module:build`,
+        "db:migrations:sync": `${scriptsPrefix} db:migrations:sync`,
+        "db:init": `${scriptsPrefix} db:init`,
+        "readme:create": `${scriptsPrefix} readme:create`,
+    };
+    pkg.scripts = { ...pkg.scripts, ...scripts };
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+    console.log(chalk.green("✓ Scripts ajoutés au package.json"));
+}
+async function saveModulesConfig(targetDir, selectedModules, withAuth) {
+    const modulesConfigPath = path.join(targetDir, ".lastbrain", "modules.json");
+    await fs.ensureDir(path.dirname(modulesConfigPath));
+    const modules = [];
+    // Ajouter TOUS les modules disponibles
+    for (const availableModule of AVAILABLE_MODULES) {
+        const isSelected = selectedModules.includes(availableModule.name) ||
+            (withAuth && availableModule.name === "auth");
+        // Vérifier si le module a des migrations
+        const modulePath = path.join(targetDir, "node_modules", ...availableModule.package.split("/"));
+        const migrationsDir = path.join(modulePath, "supabase", "migrations");
+        const moduleConfig = {
+            package: availableModule.package,
+            active: isSelected,
+        };
+        if (fs.existsSync(migrationsDir)) {
+            const migrationFiles = fs
+                .readdirSync(migrationsDir)
+                .filter((f) => f.endsWith(".sql"));
+            if (migrationFiles.length > 0) {
+                moduleConfig.migrations = isSelected ? migrationFiles : [];
+            }
+        }
+        modules.push(moduleConfig);
+    }
+    await fs.writeJson(modulesConfigPath, { modules }, { spaces: 2 });
+    console.log(chalk.green("✓ Configuration des modules sauvegardée"));
+}
+async function createStorageProxy(targetDir, force) {
+    console.log(chalk.yellow("\n🗂️  Création du système de proxy storage..."));
+    // Créer le dossier lib
+    const libDir = path.join(targetDir, "lib");
+    await fs.ensureDir(libDir);
+    // 1. Créer lib/bucket-config.ts
+    const bucketConfigPath = path.join(libDir, "bucket-config.ts");
+    if (!fs.existsSync(bucketConfigPath) || force) {
+        const bucketConfigContent = `/**
+ * Storage configuration for buckets and access control
+ */
+
+export interface BucketConfig {
+  name: string;
+  isPublic: boolean;
+  description: string;
+  allowedFileTypes?: string[];
+  maxFileSize?: number; // in bytes
+  customAccessControl?: (userId: string, filePath: string) => boolean;
+}
+
+export const BUCKET_CONFIGS: Record<string, BucketConfig> = {
+  avatar: {
+    name: "avatar",
+    isPublic: true,
+    description: "User profile pictures and avatars",
+    allowedFileTypes: ["image/jpeg", "image/png", "image/webp", "image/gif"],
+    maxFileSize: 10 * 1024 * 1024, // 10MB
+  },
+  app: {
+    name: "app",
+    isPublic: false,
+    description: "Private user files and documents",
+    maxFileSize: 100 * 1024 * 1024, // 100MB
+    customAccessControl: (userId: string, filePath: string) => {
+      // Users can only access files in their own folder (app/{userId}/...)
+      return filePath.startsWith(\`\${userId}/\`);
+    },
+  },
+  recipes: {
+    name: "recipes",
+    isPublic: true,
+    description: "Public recipe images accessible by slug",
+    allowedFileTypes: ["image/jpeg", "image/png", "image/webp", "image/gif"],
+    maxFileSize: 50 * 1024 * 1024, // 50MB
+  },
+  // Example for future buckets:
+  // public: {
+  //   name: "public",
+  //   isPublic: true,
+  //   description: "Publicly accessible files like logos, banners",
+  //   allowedFileTypes: ["image/jpeg", "image/png", "image/webp", "application/pdf"],
+  //   maxFileSize: 50 * 1024 * 1024, // 50MB
+  // },
+  // documents: {
+  //   name: "documents",
+  //   isPublic: false,
+  //   description: "Private documents requiring authentication",
+  //   allowedFileTypes: ["application/pdf", "application/msword", "text/plain"],
+  //   maxFileSize: 25 * 1024 * 1024, // 25MB
+  // },
+};
+
+/**
+ * Get bucket configuration
+ */
+export function getBucketConfig(bucketName: string): BucketConfig | null {
+  return BUCKET_CONFIGS[bucketName] || null;
+}
+
+/**
+ * Check if bucket is public
+ */
+export function isPublicBucket(bucketName: string): boolean {
+  const config = getBucketConfig(bucketName);
+  return config?.isPublic ?? false;
+}
+
+/**
+ * Check if user has access to a specific file
+ */
+export function hasFileAccess(bucketName: string, userId: string, filePath: string): boolean {
+  const config = getBucketConfig(bucketName);
+  if (!config) return false;
+
+  // Public buckets are accessible to everyone
+  if (config.isPublic) return true;
+
+  // Private buckets require authentication
+  if (!userId) return false;
+
+  // Apply custom access control if defined
+  if (config.customAccessControl) {
+    return config.customAccessControl(userId, filePath);
+  }
+
+  return true;
+}
+
+/**
+ * Validate file type for bucket
+ */
+export function isValidFileType(bucketName: string, contentType: string): boolean {
+  const config = getBucketConfig(bucketName);
+  if (!config || !config.allowedFileTypes) return true;
+
+  return config.allowedFileTypes.includes(contentType);
+}
+
+/**
+ * Check if file size is within bucket limits
+ */
+export function isValidFileSize(bucketName: string, fileSize: number): boolean {
+  const config = getBucketConfig(bucketName);
+  if (!config || !config.maxFileSize) return true;
+
+  return fileSize <= config.maxFileSize;
+}`;
+        await fs.writeFile(bucketConfigPath, bucketConfigContent);
+        console.log(chalk.green("✓ lib/bucket-config.ts créé"));
+    }
+    // 2. Créer lib/storage.ts
+    const storagePath = path.join(libDir, "storage.ts");
+    if (!fs.existsSync(storagePath) || force) {
+        const storageContent = `/**
+ * Build storage proxy URL for files in Supabase buckets
+ * 
+ * @param bucket - The bucket name (e.g., "avatar", "app")
+ * @param path - The file path within the bucket
+ * @returns Proxied URL (e.g., "/api/storage/avatar/user_128_123456.webp")
+ */
+export function buildStorageUrl(bucket: string, path: string): string {
+  // Remove leading slash if present
+  const cleanPath = path.startsWith("/") ? path.slice(1) : path;
+  
+  // Remove bucket prefix from path if present (e.g., "avatar/file.jpg" -> "file.jpg")
+  const pathWithoutBucket = cleanPath.startsWith(bucket + "/") 
+    ? cleanPath.slice(bucket.length + 1)
+    : cleanPath;
+  
+  return \`/api/storage/\${bucket}/\${pathWithoutBucket}\`;
+}
+
+/**
+ * Extract bucket and path from a storage URL
+ * 
+ * @param url - Storage URL (can be proxied URL or Supabase public URL)
+ * @returns Object with bucket and path, or null if not a valid storage URL
+ */
+export function parseStorageUrl(url: string): { bucket: string; path: string } | null {
+  // Handle proxy URLs like "/api/storage/avatar/file.jpg"
+  const proxyMatch = url.match(/^\\/api\\/storage\\/([^\\/]+)\\/(.+)$/);
+  if (proxyMatch) {
+    return {
+      bucket: proxyMatch[1],
+      path: proxyMatch[2]
+    };
+  }
+  
+  // Handle Supabase public URLs
+  const supabaseMatch = url.match(/\\/storage\\/v1\\/object\\/public\\/([^\\/]+)\\/(.+)$/);
+  if (supabaseMatch) {
+    return {
+      bucket: supabaseMatch[1],
+      path: supabaseMatch[2]
+    };
+  }
+  
+  return null;
+}
+
+/**
+ * Convert a Supabase storage path to proxy URL
+ * 
+ * @param storagePath - Path like "avatar/file.jpg" or "app/user/file.pdf"
+ * @returns Proxied URL
+ */
+export function storagePathToProxyUrl(storagePath: string): string {
+  const parts = storagePath.split("/");
+  if (parts.length < 2) {
+    throw new Error("Invalid storage path format");
+  }
+  
+  const bucket = parts[0];
+  const path = parts.slice(1).join("/");
+  
+  return buildStorageUrl(bucket, path);
+}
+
+/**
+ * List of public buckets that don't require authentication
+ */
+export const PUBLIC_BUCKETS = ["avatar"];
+
+/**
+ * List of private buckets that require authentication
+ */
+export const PRIVATE_BUCKETS = ["app"];
+
+/**
+ * Check if a bucket is public
+ */
+export function isPublicBucket(bucket: string): boolean {
+  return PUBLIC_BUCKETS.includes(bucket);
+}
+
+/**
+ * Check if a bucket is private
+ */
+export function isPrivateBucket(bucket: string): boolean {
+  return PRIVATE_BUCKETS.includes(bucket);
+}`;
+        await fs.writeFile(storagePath, storageContent);
+        console.log(chalk.green("✓ lib/storage.ts créé"));
+    }
+    // 3. Créer app/api/storage/[bucket]/[...path]/route.ts
+    const apiStorageDir = path.join(targetDir, "app", "api", "storage", "[bucket]", "[...path]");
+    await fs.ensureDir(apiStorageDir);
+    const routePath = path.join(apiStorageDir, "route.ts");
+    if (!fs.existsSync(routePath) || force) {
+        const routeContent = `import { NextRequest, NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { getBucketConfig, hasFileAccess } from "@/lib/bucket-config";
+
+/**
+ * GET /api/storage/[bucket]/[...path]
+ * Proxy for Supabase Storage files with clean URLs and access control
+ * 
+ * Examples:
+ * - /api/storage/avatar/user_128_123456.webp
+ * - /api/storage/app/user/documents/file.pdf
+ */
+export async function GET(
+  request: NextRequest,
+  props: { params: Promise<{ bucket: string; path: string[] }> }
+) {
+  try {
+    const { bucket, path } = await props.params;
+    const filePath = path.join("/");
+
+    // Check if bucket exists in our configuration
+    const bucketConfig = getBucketConfig(bucket);
+    if (!bucketConfig) {
+      return new NextResponse("Bucket not allowed", { status: 403 });
+    }
+
+    const supabase = await getSupabaseServerClient();
+    let userId: string | null = null;
+
+    // Get user for private buckets or custom access control
+    if (!bucketConfig.isPublic) {
+      const { data: { user }, error: authError } = await supabase.auth.getUser();
+      
+      if (authError || !user) {
+        return new NextResponse("Unauthorized", { status: 401 });
+      }
+
+      userId = user.id;
+    }
+
+    // Check file access permissions
+    if (!hasFileAccess(bucket, userId || "", filePath)) {
+      return new NextResponse("Forbidden - Access denied to this file", { status: 403 });
+    }
+
+    // Get file from Supabase Storage
+    const { data: file, error } = await supabase.storage
+      .from(bucket)
+      .download(filePath);
+
+    if (error) {
+      console.error("Storage download error:", error);
+      if (error.message.includes("not found")) {
+        return new NextResponse("File not found", { status: 404 });
+      }
+      return new NextResponse("Storage error", { status: 500 });
+    }
+
+    if (!file) {
+      return new NextResponse("File not found", { status: 404 });
+    }
+
+    // Convert blob to array buffer
+    const arrayBuffer = await file.arrayBuffer();
+
+    // Determine content type from file extension
+    const getContentType = (filename: string): string => {
+      const ext = filename.toLowerCase().split(".").pop();
+      const mimeTypes: Record<string, string> = {
+        // Images
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        webp: "image/webp",
+        svg: "image/svg+xml",
+        // Documents
+        pdf: "application/pdf",
+        doc: "application/msword",
+        docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        xls: "application/vnd.ms-excel",
+        xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        // Text
+        txt: "text/plain",
+        csv: "text/csv",
+        // Videos
+        mp4: "video/mp4",
+        avi: "video/x-msvideo",
+        mov: "video/quicktime",
+        // Audio
+        mp3: "audio/mpeg",
+        wav: "audio/wav",
+        // Archives
+        zip: "application/zip",
+        rar: "application/x-rar-compressed",
+      };
+      return mimeTypes[ext || ""] || "application/octet-stream";
+    };
+
+    const contentType = getContentType(filePath);
+
+    // Create response with proper headers
+    const response = new NextResponse(arrayBuffer, {
+      status: 200,
+      headers: {
+        "Content-Type": contentType,
+        "Cache-Control": "public, max-age=31536000, immutable", // Cache for 1 year
+        "Content-Length": arrayBuffer.byteLength.toString(),
+      },
+    });
+
+    return response;
+
+  } catch (error) {
+    console.error("Storage proxy error:", error);
+    return new NextResponse("Internal server error", { status: 500 });
+  }
+}`;
+        await fs.writeFile(routePath, routeContent);
+        console.log(chalk.green("✓ app/api/storage/[bucket]/[...path]/route.ts créé"));
+    }
+    console.log(chalk.green("✓ Système de proxy storage configuré"));
+}