@lastbrain/app 0.1.8 → 0.1.10

package/src/scripts/init-app.ts

@@ -0,0 +1,1076 @@
+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 "./module-add.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface InitAppOptions {
+  targetDir: string;
+  force: boolean;
+  projectName: string;
+  useHeroUI: boolean;
+  withAuth?: boolean;
+  interactive?: boolean;
+}
+
+export async function initApp(options: InitAppOptions) {
+  const {
+    targetDir,
+    force,
+    projectName,
+    useHeroUI,
+    interactive = true,
+  } = options;
+  let { withAuth = 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: string[] = [];
+  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.displayName} - ${module.description}`,
+          value: module.name,
+          checked: false,
+        })),
+      },
+    ]);
+
+    selectedModules.push(...answers.modules);
+    withAuth = selectedModules.includes("auth");
+
+    console.log();
+  }
+
+  // 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);
+
+  // 5. Créer .gitignore et .env.local.example
+  await createGitIgnore(targetDir, force);
+  await createEnvExample(targetDir, force);
+
+  // 6. Créer la structure Supabase avec migrations
+  await createSupabaseStructure(targetDir, force);
+
+  // 7. Ajouter les scripts NPM
+  await addScriptsToPackageJson(targetDir);
+
+  // 8. Enregistrer les modules sélectionnés
+  if (withAuth || 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"));
+
+      // 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"));
+      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 (error) {
+          // Ignorer les erreurs d'ouverture du navigateur
+        }
+      }, 2000);
+
+      // Lancer pnpm dev
+      execSync("pnpm dev", { cwd: targetDir, stdio: "inherit" });
+    } catch (error) {
+      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 dev\n"));
+    }
+  } else {
+    console.log(chalk.cyan("\n📋 Prochaines étapes:"));
+    console.log(chalk.white("  1. cd " + relativePath));
+    console.log(chalk.white("  2. pnpm install"));
+    console.log(chalk.white("  3. pnpm build:modules (générer les routes des modules)"));
+    console.log(chalk.white("  4. pnpm dev (démarrer le serveur de développement)"));
+    console.log(chalk.white("\n  Puis sur la page d'accueil :"));
+    console.log(chalk.white("  5. Cliquez sur 'Get Started'"));
+    console.log(chalk.white("  6. Lancez Docker Desktop"));
+    console.log(chalk.white("  7. Installez Supabase CLI : brew install supabase/tap/supabase"));
+    console.log(chalk.white("  8. Exécutez : pnpm db:init"));
+    console.log(chalk.white("  9. Rechargez la page\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: string, projectName: string) {
+  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"));
+  }
+}
+
+async function addDependencies(
+  targetDir: string,
+  useHeroUI: boolean,
+  withAuth: boolean,
+  selectedModules: string[] = []
+) {
+  const pkgPath = path.join(targetDir, "package.json");
+  const pkg = await fs.readJson(pkgPath);
+
+  console.log(chalk.yellow("\n📦 Configuration des dépendances..."));
+
+  // Détecter si on est dans le monorepo (développement local)
+  // Vérifier si le projet cible est à l'intérieur du monorepo
+  const targetIsInMonorepo = fs.existsSync(path.join(targetDir, "../../../packages/core/package.json")) ||
+                               fs.existsSync(path.join(targetDir, "../../packages/core/package.json"));
+  const latestVersion = targetIsInMonorepo ? "workspace:*" : "latest";
+  
+  // Dependencies
+  const requiredDeps: Record<string, string> = {
+    next: "^15.0.3",
+    react: "^18.3.1",
+    "react-dom": "^18.3.1",
+    "@lastbrain/app": latestVersion,
+    "@lastbrain/core": latestVersion,
+    "@lastbrain/ui": latestVersion,
+    "next-themes": "^0.4.6",
+  };
+
+  // Ajouter module-auth si demandé
+  if (withAuth) {
+    requiredDeps["@lastbrain/module-auth"] = latestVersion;
+  }
+
+  // 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") {
+      requiredDeps[moduleInfo.package] = latestVersion;
+    }
+  }
+
+  // Ajouter les dépendances HeroUI si nécessaire
+  if (useHeroUI) {
+    // Core
+    requiredDeps["@heroui/system"] = "^2.4.23";
+    requiredDeps["@heroui/theme"] = "^2.4.23";
+    requiredDeps["@heroui/react-utils"] = "^2.1.14";
+    requiredDeps["@heroui/framer-utils"] = "^2.1.23";
+
+    // Buttons & Actions
+    requiredDeps["@heroui/button"] = "^2.2.27";
+    requiredDeps["@heroui/link"] = "^2.2.23";
+
+    // Forms
+    requiredDeps["@heroui/input"] = "^2.4.28";
+    requiredDeps["@heroui/checkbox"] = "^2.3.27";
+    requiredDeps["@heroui/radio"] = "^2.3.27";
+    requiredDeps["@heroui/select"] = "^2.4.28";
+    requiredDeps["@heroui/switch"] = "^2.2.24";
+    requiredDeps["@heroui/form"] = "^2.1.27";
+    requiredDeps["@heroui/autocomplete"] = "^2.3.29";
+
+    // Layout
+    requiredDeps["@heroui/card"] = "^2.2.25";
+    requiredDeps["@heroui/navbar"] = "^2.2.25";
+    requiredDeps["@heroui/divider"] = "^2.2.20";
+    requiredDeps["@heroui/spacer"] = "^2.2.21";
+
+    // Navigation
+    requiredDeps["@heroui/tabs"] = "^2.2.24";
+    requiredDeps["@heroui/breadcrumbs"] = "^2.2.19";
+    requiredDeps["@heroui/pagination"] = "^2.2.24";
+    requiredDeps["@heroui/listbox"] = "^2.3.26";
+
+    // Feedback
+    requiredDeps["@heroui/spinner"] = "^2.2.24";
+    requiredDeps["@heroui/progress"] = "^2.2.22";
+    requiredDeps["@heroui/skeleton"] = "^2.2.17";
+    requiredDeps["@heroui/alert"] = "^2.2.27";
+    requiredDeps["@heroui/toast"] = "^2.0.17";
+
+    // Overlays
+    requiredDeps["@heroui/modal"] = "^2.2.24";
+    requiredDeps["@heroui/tooltip"] = "^2.2.24";
+    requiredDeps["@heroui/popover"] = "^2.3.27";
+    requiredDeps["@heroui/dropdown"] = "^2.3.27";
+    requiredDeps["@heroui/drawer"] = "^2.2.24";
+
+    // Data Display
+    requiredDeps["@heroui/avatar"] = "^2.2.22";
+    requiredDeps["@heroui/badge"] = "^2.2.17";
+    requiredDeps["@heroui/chip"] = "^2.2.22";
+    requiredDeps["@heroui/code"] = "^2.2.21";
+    requiredDeps["@heroui/image"] = "^2.2.17";
+    requiredDeps["@heroui/kbd"] = "^2.2.22";
+    requiredDeps["@heroui/snippet"] = "^2.2.28";
+    requiredDeps["@heroui/table"] = "^2.2.27";
+    requiredDeps["@heroui/user"] = "^2.2.22";
+    requiredDeps["@heroui/accordion"] = "^2.2.24";
+
+    // Utilities
+    requiredDeps["@heroui/scroll-shadow"] = "^2.3.18";
+    requiredDeps["@react-aria/ssr"] = "^3.9.10";
+    requiredDeps["@react-aria/visually-hidden"] = "^3.8.28";
+
+    // Dependencies
+    requiredDeps["lucide-react"] = "^0.554.0";
+    requiredDeps["framer-motion"] = "^11.18.2";
+    requiredDeps["clsx"] = "^2.1.1";
+  }
+
+  // DevDependencies
+  const requiredDevDeps = {
+    tailwindcss: "^3.4.0",
+    postcss: "^8.4.0",
+    autoprefixer: "^10.4.20",
+    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: string,
+  force: boolean,
+  useHeroUI: boolean,
+  withAuth: boolean
+) {
+  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
+      layoutContent = `// GENERATED BY LASTBRAIN APP-SHELL
+
+"use client";
+
+import "../styles/globals.css";
+import { HeroUIProvider } from "@heroui/system";
+
+import { ThemeProvider } from "next-themes";
+import { useRouter } from "next/navigation";
+import { AppProviders } from "@lastbrain/app";
+import type { PropsWithChildren } from "react";
+import { AppHeader } from "../components/AppHeader";
+
+export default function RootLayout({ children }: PropsWithChildren<{}>) {
+  const router = useRouter();
+
+  return (
+    <html lang="fr" suppressHydrationWarning>
+      <body className="min-h-screen">
+        <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>
+      </body>
+    </html>
+  );
+}
+`;
+    } else {
+      // Layout Tailwind CSS uniquement
+      layoutContent = `// GENERATED BY LASTBRAIN APP-SHELL
+
+"use client";
+
+import "../styles/globals.css";
+import { ThemeProvider } from "next-themes";
+import { AppProviders } from "@lastbrain/app";
+import type { PropsWithChildren } from "react";
+import { AppHeader } from "../components/AppHeader";
+
+export default function RootLayout({ children }: PropsWithChildren<{}>) {
+  return (
+    <html lang="fr" suppressHydrationWarning>
+      <body className="min-h-screen">
+        <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>
+      </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 = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`;
+    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";
+
+export default function RootPage() {
+  return <SimpleHomePage showAuth={${withAuth}} />;
+}
+`;
+    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, "docs", "public", force);
+
+  // Créer le composant AppHeader
+  await createAppHeader(targetDir, force);
+}
+
+async function createRoute(
+  appDir: string,
+  routeName: string,
+  layoutType: string,
+  force: boolean
+) {
+  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) {
+    const layoutComponent =
+      layoutType.charAt(0).toUpperCase() + layoutType.slice(1) + "Layout";
+
+    const layoutContent = `import { ${layoutComponent} } from "@lastbrain/app";
+
+export default ${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: string | null = 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: string, force: boolean) {
+  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 } from "@lastbrain/ui";
+import { menuConfig } from "../config/menu";
+import { supabaseBrowserClient } from "@lastbrain/core";
+import { useRouter } from "next/navigation";
+import { useAuthSession } from "@lastbrain/app";
+
+export function AppHeader() {
+  const router = useRouter();
+  const { user, isSuperAdmin } = useAuthSession();
+
+  const handleLogout = async () => {
+    await supabaseBrowserClient.auth.signOut();
+    router.push("/");
+    router.refresh();
+  };
+
+  return (
+    <Header
+      user={user}
+      onLogout={handleLogout}
+      menuConfig={menuConfig}
+      brandName="LastBrain App"
+      brandHref="/"
+      isSuperAdmin={isSuperAdmin}
+    />
+  );
+}
+`;
+    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 createConfigFiles(
+  targetDir: string,
+  force: boolean,
+  useHeroUI: boolean
+) {
+  console.log(chalk.yellow("\n⚙️  Création des fichiers de configuration..."));
+
+  // middleware.ts - Protection des routes /auth/* et /admin/*
+  const middlewarePath = path.join(targetDir, "middleware.ts");
+  if (!fs.existsSync(middlewarePath) || force) {
+    const middleware = `import { type NextRequest, NextResponse } from "next/server";
+import { createMiddlewareClient } from "@lastbrain/core/server";
+
+export async function middleware(request: NextRequest) {
+  const { pathname } = request.nextUrl;
+
+  // 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 → redirection vers /signin
+      if (!session) {
+        const redirectUrl = new URL("/signin", request.url);
+        redirectUrl.searchParams.set("redirect", pathname);
+        return NextResponse.redirect(redirectUrl);
+      }
+
+      return response;
+    } catch (error) {
+      console.error("Middleware auth error:", error);
+      return NextResponse.redirect(new URL("/signin", request.url));
+    }
+  }
+
+  // Protéger les routes /admin/* (superadmin uniquement)
+  if (pathname.startsWith("/admin")) {
+    try {
+      const { supabase, response } = createMiddlewareClient(request);
+      const {
+        data: { session },
+      } = await supabase.auth.getSession();
+
+      // Pas de session → redirection vers /signin
+      if (!session) {
+        const redirectUrl = new URL("/signin", request.url);
+        redirectUrl.searchParams.set("redirect", pathname);
+        return NextResponse.redirect(redirectUrl);
+      }
+
+      // 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);
+        return NextResponse.redirect(new URL("/", request.url));
+      }
+
+      return response;
+    } catch (error) {
+      console.error("Middleware admin error:", error);
+      return NextResponse.redirect(new URL("/", request.url));
+    }
+  }
+
+  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/* et /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,
+};
+
+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
+      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/**/*.{js,jsx,ts,tsx}",
+    "./node_modules/@heroui/**/*.{js,jsx,ts,tsx}"
+  ],
+  theme: {
+    extend: {},
+  },
+  darkMode: "class",
+  plugins: [heroui()],
+}
+
+export default config;
+`;
+    } else {
+      // Configuration Tailwind CSS uniquement
+      tailwindConfig = `module.exports = {
+  content: [
+    "./app/**/*.{js,ts,jsx,tsx,mdx}",
+    "./components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./node_modules/@lastbrain/**/*.{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: [],
+};
+`;
+    }
+
+    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: {},
+    autoprefixer: {},
+  },
+};
+`;
+    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) {
+    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: {
+          "@/*": ["./*"],
+        },
+      },
+      include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+      exclude: ["node_modules"],
+    };
+    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éé"));
+  }
+}
+
+async function createGitIgnore(targetDir: string, force: boolean) {
+  const gitignorePath = path.join(targetDir, ".gitignore");
+
+  if (!fs.existsSync(gitignorePath) || force) {
+    console.log(chalk.yellow("\n📝 Création de .gitignore..."));
+
+    const gitignoreContent = `# Dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# Testing
+coverage/
+
+# Next.js
+.next/
+out/
+build/
+dist/
+
+# Production
+*.log*
+
+# Misc
+.DS_Store
+*.pem
+
+# Debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Local env files
+.env
+.env*.local
+.env.production
+
+# Vercel
+.vercel
+
+# Typescript
+*.tsbuildinfo
+next-env.d.ts
+
+# Supabase
+supabase/.temp/
+supabase/.branches/
+
+# LastBrain generated
+**/navigation.generated.ts
+**/routes.generated.ts
+`;
+    await fs.writeFile(gitignorePath, gitignoreContent);
+    console.log(chalk.green("✓ .gitignore créé"));
+  }
+}
+
+async function createEnvExample(targetDir: string, force: boolean) {
+  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 createSupabaseStructure(targetDir: string, force: boolean) {
+  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: string) {
+  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"));
+
+  let scriptsPrefix = "node node_modules/@lastbrain/app/dist/scripts/";
+  
+  if (targetIsInMonorepo) {
+    // Dans un monorepo, utiliser pnpm exec pour résoudre correctement les workspace packages
+    scriptsPrefix = "pnpm exec lastbrain ";
+  }
+
+  const scripts = {
+    dev: "next dev",
+    build: "next build",
+    start: "next start",
+    lint: "next lint",
+    lastbrain: targetIsInMonorepo 
+      ? "pnpm exec lastbrain"
+      : "node node_modules/@lastbrain/app/dist/cli.js",
+    "build:modules": targetIsInMonorepo
+      ? "pnpm exec lastbrain module:build"
+      : "node node_modules/@lastbrain/app/dist/scripts/module-build.js",
+    "db:migrations:sync": targetIsInMonorepo
+      ? "pnpm exec lastbrain db:migrations:sync"
+      : "node node_modules/@lastbrain/app/dist/scripts/db-migrations-sync.js",
+    "db:init": targetIsInMonorepo
+      ? "pnpm exec lastbrain db:init"
+      : "node node_modules/@lastbrain/app/dist/scripts/db-init.js",
+    "readme:create": targetIsInMonorepo
+      ? "pnpm exec lastbrain readme:create"
+      : "node node_modules/@lastbrain/app/dist/scripts/readme-build.js",
+  };
+
+  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: string,
+  selectedModules: string[],
+  withAuth: boolean
+) {
+  const modulesConfigPath = path.join(targetDir, ".lastbrain", "modules.json");
+  await fs.ensureDir(path.dirname(modulesConfigPath));
+
+  const modules: Array<{ package: string; active: boolean; migrations?: string[] }> = [];
+
+  // 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: string; active: boolean; migrations?: string[] } = {
+      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"));
+}