@lastbrain/app 0.1.0

package/dist/scripts/init-app.js

@@ -0,0 +1,846 @@
+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);
+export async function initApp(options) {
+    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 = [];
+    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);
+    // 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`));
+            // 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("\nProchaines étapes:"));
+        console.log(chalk.white("  1. cd " + relativePath));
+        console.log(chalk.white("  2. pnpm install"));
+        console.log(chalk.white("  3. pnpm db:init (pour initialiser Supabase local)"));
+        console.log(chalk.white("  4. pnpm build:modules (pour générer les routes des modules)"));
+        console.log(chalk.white("  5. pnpm dev (pour démarrer le serveur de développement)\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"));
+    }
+}
+async function addDependencies(targetDir, useHeroUI, withAuth) {
+    const pkgPath = path.join(targetDir, "package.json");
+    const pkg = await fs.readJson(pkgPath);
+    console.log(chalk.yellow("\n📦 Configuration des dépendances..."));
+    // Dependencies
+    const requiredDeps = {
+        next: "^15.0.3",
+        react: "^18.3.1",
+        "react-dom": "^18.3.1",
+        "@lastbrain/app": "workspace:*",
+        "@lastbrain/core": "workspace:*",
+        "@lastbrain/ui": "workspace:*",
+        "next-themes": "^0.4.6",
+    };
+    // Ajouter module-auth si demandé
+    if (withAuth) {
+        requiredDeps["@lastbrain/module-auth"] = "workspace:*";
+    }
+    // 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/postcss": "^4.0.0",
+        tailwindcss: "^4.0.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
+            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 = `@config "../tailwind.config.mjs";
+@import "tailwindcss";
+`;
+        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, 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) {
+        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 = 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 } 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, force, useHeroUI) {
+    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/*/dist/**/*.js",
+    "./node_modules/@heroui/theme/dist/**/*.{js,ts,jsx,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/*/dist/**/*.js",
+  ],
+  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 = `const config = {
+  plugins: {
+    '@tailwindcss/postcss': {},
+    autoprefixer: {},
+  },
+};
+
+export default config;
+`;
+        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éé"));
+    }
+}
+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..."));
+        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, 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 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);
+    const scripts = {
+        dev: "next dev",
+        build: "next build",
+        start: "next start",
+        lint: "next lint",
+        lastbrain: "node node_modules/@lastbrain/app/dist/cli.js",
+        "build:modules": "PROJECT_ROOT=$PWD pnpm --filter @lastbrain/app module:build",
+        "db:migrations:sync": "PROJECT_ROOT=$PWD pnpm --filter @lastbrain/app db:migrations:sync",
+        "db:init": "PROJECT_ROOT=$PWD pnpm --filter @lastbrain/app db:init",
+        "readme:create": "PROJECT_ROOT=$PWD pnpm --filter @lastbrain/app 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"));
+}