@lastbrain/app 2.0.1 → 2.0.3

package/dist/src/scripts/module-create.js

@@ -0,0 +1,1429 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Noms réservés pour éviter les collisions avec le routeur/app
+const RESERVED_PAGE_NAMES = new Set([
+    "layout",
+    "page",
+    "api",
+    "admin",
+    "auth",
+    "public",
+]);
+/**
+ * Parse une chaîne de pages séparées par des virgules
+ * Ex: "legal, privacy, terms" => ["legal", "privacy", "terms"]
+ */
+function parsePagesList(input) {
+    if (!input || input.trim() === "")
+        return [];
+    return input
+        .split(",")
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+}
+/**
+ * Slugifie un nom de page: minuscules, tirets, alphanum uniquement
+ */
+function slugifyPageName(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[\s_]+/g, "-")
+        .replace(/[^a-z0-9-]/g, "")
+        .replace(/--+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Parse une chaîne de tables séparées par des virgules
+ * Ex: "settings, users" => ["settings", "users"]
+ */
+function parseTablesList(input) {
+    if (!input || input.trim() === "")
+        return [];
+    return input
+        .split(",")
+        .map((t) => t.trim())
+        .filter((t) => t.length > 0);
+}
+/**
+ * Récupère les versions actuelles des packages LastBrain
+ */
+function getLastBrainPackageVersions(rootDir) {
+    try {
+        const corePackageJson = JSON.parse(fs.readFileSync(path.join(rootDir, "packages", "core", "package.json"), "utf-8"));
+        const uiPackageJson = JSON.parse(fs.readFileSync(path.join(rootDir, "packages", "ui", "package.json"), "utf-8"));
+        return {
+            core: `^${corePackageJson.version}`,
+            ui: `^${uiPackageJson.version}`,
+        };
+    }
+    catch {
+        console.warn(chalk.yellow("⚠️  Impossible de lire les versions des packages, utilisation des versions par défaut"));
+        return {
+            core: "^0.1.0",
+            ui: "^0.1.4",
+        };
+    }
+}
+/**
+ * Génère le contenu du package.json
+ */
+function generatePackageJson(moduleName, slug, rootDir) {
+    const versions = getLastBrainPackageVersions(rootDir);
+    const moduleNameOnly = slug.replace("module-", "");
+    const buildConfigExport = `./${moduleNameOnly}.build.config`;
+    return JSON.stringify({
+        name: moduleName,
+        version: "0.1.0",
+        private: false,
+        type: "module",
+        main: "dist/index.js",
+        types: "dist/index.d.ts",
+        files: ["dist", "src", "supabase"],
+        scripts: {
+            build: "tsc -p tsconfig.json",
+            dev: "tsc -p tsconfig.json --watch",
+        },
+        dependencies: {
+            "@lastbrain/core": versions.core,
+            "@lastbrain/ui": versions.ui,
+            react: "^19.0.0",
+            "lucide-react": "^0.554.0",
+            "react-dom": "^19.0.0",
+        },
+        devDependencies: {
+            typescript: "^5.4.0",
+        },
+        exports: {
+            ".": {
+                types: "./dist/index.d.ts",
+                default: "./dist/index.js",
+            },
+            "./server": {
+                types: "./dist/server.d.ts",
+                default: "./dist/server.js",
+            },
+            [buildConfigExport]: {
+                types: `./dist/${moduleNameOnly}.build.config.d.ts`,
+                default: `./dist/${moduleNameOnly}.build.config.js`,
+            },
+            "./api/*": {
+                types: "./dist/api/*.d.ts",
+                default: "./dist/api/*.js",
+            },
+        },
+        sideEffects: false,
+    }, null, 2);
+}
+/**
+ * Génère le contenu du tsconfig.json
+ */
+function generateTsConfig() {
+    return JSON.stringify({
+        extends: "../../tsconfig.base.json",
+        compilerOptions: {
+            outDir: "dist",
+            rootDir: "src",
+            declaration: true,
+        },
+        include: ["src"],
+    }, null, 2);
+}
+/**
+ * Génère le contenu du fichier build.config.ts
+ */
+function generateBuildConfig(config) {
+    const { moduleName, pages, tables } = config;
+    const moduleNameOnly = config.slug.replace("module-", "");
+    // Helper pour normaliser les chemins (évite // et trim)
+    function normalizePath(...segments) {
+        return ("/" +
+            segments
+                .map((s) => s.replace(/^\/+/g, "").replace(/\/+$/g, ""))
+                .filter(Boolean)
+                .join("/"));
+    }
+    // Construit un path de menu selon la section en respectant le pattern attendu
+    function buildMenuPath(section, pagePath, pageName) {
+        const cleanedPagePath = pagePath.replace(/^\/+/g, "");
+        switch (section) {
+            case "public": {
+                // Public: /<module>/<page> (si non déjà préfixé)
+                if (cleanedPagePath.startsWith(moduleNameOnly + "/")) {
+                    return normalizePath(cleanedPagePath); // déjà préfixé
+                }
+                return normalizePath(moduleNameOnly, cleanedPagePath);
+            }
+            case "auth": {
+                // Auth: /auth/<module>/<page>
+                return normalizePath("auth", moduleNameOnly, cleanedPagePath);
+            }
+            case "admin": {
+                // Admin: /admin/<module>/<pageName> (utilise le slug brut)
+                return normalizePath("admin", moduleNameOnly, pageName);
+            }
+            default:
+                return normalizePath(cleanedPagePath);
+        }
+    }
+    // Générer la liste des pages
+    const pagesConfig = pages.map((page) => {
+        const componentName = page.name
+            .split("-")
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join("");
+        return `    {
+      section: "${page.section}",
+      path: "${page.path}",
+      componentExport: "${componentName}Page",
+    }`;
+    });
+    // Générer la liste des APIs
+    const apisConfig = [];
+    for (const table of tables) {
+        for (const section of table.sections) {
+            const methods = ["GET", "POST", "PUT", "DELETE"];
+            for (const method of methods) {
+                apisConfig.push(`    {
+      method: "${method}",
+      path: "/api/${section}/${table.name}",
+      handlerExport: "${method}",
+      entryPoint: "api/${section}/${table.name}",
+      authRequired: ${section !== "public"},
+    }`);
+            }
+        }
+    }
+    // Générer les menus par section
+    const menuSections = [];
+    // Menu public
+    const publicPages = pages.filter((p) => p.section === "public");
+    if (publicPages.length > 0) {
+        const publicMenuItems = publicPages.map((page, index) => {
+            const title = page.name
+                .split("-")
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                .join(" ");
+            const menuPath = buildMenuPath("public", page.path, page.name);
+            return `      {
+        title: "${title}",
+        description: "Page ${title}",
+        icon: "FileText",
+        path: "${menuPath}",
+        order: ${index + 1},
+      }`;
+        });
+        menuSections.push({ section: "public", items: publicMenuItems });
+    }
+    // Menu auth
+    const authPages = pages.filter((p) => p.section === "auth");
+    if (authPages.length > 0) {
+        const authMenuItems = authPages.map((page, index) => {
+            const title = page.name
+                .split("-")
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                .join(" ");
+            const menuPath = buildMenuPath("auth", page.path, page.name);
+            return `      {
+        title: "${title}",
+        description: "Page ${title}",
+        icon: "FileText",
+        path: "${menuPath}",
+        order: ${index + 1},
+      }`;
+        });
+        menuSections.push({ section: "auth", items: authMenuItems });
+    }
+    // Menu admin
+    const adminPages = pages.filter((p) => p.section === "admin");
+    if (adminPages.length > 0) {
+        const adminMenuItems = adminPages.map((page, index) => {
+            const title = page.name
+                .split("-")
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                .join(" ");
+            const menuPath = buildMenuPath("admin", page.path, page.name);
+            return `      {
+        title: "${title}",
+        description: "Page ${title}",
+        icon: "Settings",
+        path: "${menuPath}",
+        order: ${index + 1},
+      }`;
+        });
+        menuSections.push({ section: "admin", items: adminMenuItems });
+    }
+    // Générer la configuration menu
+    const menuConfig = menuSections.length > 0
+        ? `,
+  menu: {
+${menuSections
+            .map(({ section, items }) => `    ${section}: [
+${items.join(",\n")}
+    ]`)
+            .join(",\n")}
+  }`
+        : "";
+    return `import type { ModuleBuildConfig } from "@lastbrain/core";
+
+const buildConfig: ModuleBuildConfig = {
+  moduleName: "${moduleName}",
+  pages: [
+${pagesConfig.join(",\n")}
+  ],
+  apis: [
+${apisConfig.join(",\n")}
+  ],
+  migrations: {
+    enabled: true,
+    priority: 30,
+    path: "supabase/migrations",
+    files: ${tables.length > 0 ? `["001_${config.slug}_init.sql"]` : "[]"},
+  }${menuConfig},
+};
+
+export default buildConfig;
+`;
+}
+/**
+ * Génère le contenu du fichier index.ts
+ */
+function toPascalCase(value) {
+    return value
+        .split(/[-_]/g)
+        .filter(Boolean)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join("");
+}
+function generateIndexTs(pages, moduleNameOnly) {
+    const exports = pages.map((page) => {
+        const componentName = toPascalCase(page.name);
+        const fileName = toPascalCase(page.name);
+        return `export { ${componentName}Page } from "./web/${page.section}/${fileName}Page";`;
+    });
+    const moduleAlias = toPascalCase(moduleNameOnly);
+    return `// Client Components
+${exports.join("\n")}
+
+// Documentation Component 
+export { Doc } from "./components/Doc";
+export { Doc as ${moduleAlias}ModuleDoc } from "./components/Doc";
+
+// Configuration de build
+export { default as buildConfig } from "./${moduleNameOnly}.build.config";
+`;
+}
+/**
+ * Génère le contenu du fichier server.ts
+ */
+function _generateServerTs(tables) {
+    const exports = [];
+    for (const table of tables) {
+        for (const section of table.sections) {
+            exports.push(`export { GET, POST, PUT, DELETE } from "./api/${section}/${table.name}.js";`);
+        }
+    }
+    return `// Server-only exports (Route Handlers, Server Actions, etc.)
+${exports.join("\n")}
+`;
+}
+/**
+ * Génère le contenu d'une page
+ */
+function generatePageComponent(pageName, section) {
+    const componentName = pageName
+        .split("-")
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join("");
+    return `"use client";
+
+import { Card, CardBody, CardHeader } from "@lastbrain/ui";
+
+export function ${componentName}Page() {
+  return (
+    <div className="container mx-auto p-6">
+      <Card>
+        <CardHeader>
+          <h1 className="text-2xl font-bold">${componentName}</h1>
+        </CardHeader>
+        <CardBody>
+          <p className="text-default-600">
+            Contenu de la page ${pageName} (section: ${section})
+          </p>
+        </CardBody>
+      </Card>
+    </div>
+  );
+}
+`;
+}
+/**
+ * Génère le contenu d'une route API CRUD
+ */
+function generateApiRoute(tableName, section) {
+    const authRequired = section !== "public";
+    const clientImport = section === "admin"
+        ? 'import { getSupabaseServiceClient } from "@lastbrain/core/server"'
+        : 'import { getSupabaseServerClient } from "@lastbrain/core/server"';
+    const clientGetter = section === "admin"
+        ? "getSupabaseServiceClient"
+        : "getSupabaseServerClient";
+    return `${clientImport};
+
+const jsonResponse = (payload: unknown, status = 200) => {
+  return new Response(JSON.stringify(payload), {
+    headers: {
+      "content-type": "application/json"
+    },
+    status
+  });
+};
+
+/**
+ * GET - Liste tous les enregistrements de ${tableName}
+ */
+export async function GET(request: Request) {
+  const supabase = await ${clientGetter}();
+  ${authRequired
+        ? `
+  const { data: { user }, error: authError } = await supabase.auth.getUser();
+  if (authError || !user) {
+    return jsonResponse({ error: "Non authentifié" }, 401);
+  }
+  `
+        : ""}
+
+  const { data, error } = await supabase
+    .from("${tableName}")
+    .select("*");
+
+  if (error) {
+    return jsonResponse({ error: error.message }, 400);
+  }
+
+  return jsonResponse({ data });
+}
+
+/**
+ * POST - Crée un nouvel enregistrement dans ${tableName}
+ */
+export async function POST(request: Request) {
+  const supabase = await ${clientGetter}();
+  ${authRequired
+        ? `
+  const { data: { user }, error: authError } = await supabase.auth.getUser();
+  if (authError || !user) {
+    return jsonResponse({ error: "Non authentifié" }, 401);
+  }
+  `
+        : ""}
+
+  const body = await request.json();
+
+  // Injection côté serveur de owner_id si l'utilisateur est authentifié (sécurité)
+  const insertPayload = ${authRequired ? `{ ...body, owner_id: user.id }` : "body"};
+
+  const { data, error } = await supabase
+    .from("${tableName}")
+    .insert(insertPayload)
+    .select()
+    .single();
+
+  if (error) {
+    return jsonResponse({ error: error.message }, 400);
+  }
+
+  return jsonResponse({ data }, 201);
+}
+
+/**
+ * PUT - Met à jour un enregistrement dans ${tableName}
+ */
+export async function PUT(request: Request) {
+  const supabase = await ${clientGetter}();
+  ${authRequired
+        ? `
+  const { data: { user }, error: authError } = await supabase.auth.getUser();
+  if (authError || !user) {
+    return jsonResponse({ error: "Non authentifié" }, 401);
+  }
+  `
+        : ""}
+
+  const body = await request.json();
+  const { id, ...updateData } = body;
+
+  if (!id) {
+    return jsonResponse({ error: "ID requis pour la mise à jour" }, 400);
+  }
+
+  const { data, error } = await supabase
+    .from("${tableName}")
+    .update(updateData)
+    .eq("id", id)
+    .select()
+    .single();
+
+  if (error) {
+    return jsonResponse({ error: error.message }, 400);
+  }
+
+  return jsonResponse({ data });
+}
+
+/**
+ * DELETE - Supprime un enregistrement de ${tableName}
+ */
+export async function DELETE(request: Request) {
+  const supabase = await ${clientGetter}();
+  ${authRequired
+        ? `
+  const { data: { user }, error: authError } = await supabase.auth.getUser();
+  if (authError || !user) {
+    return jsonResponse({ error: "Non authentifié" }, 401);
+  }
+  `
+        : ""}
+
+  const { searchParams } = new URL(request.url);
+  const id = searchParams.get("id");
+
+  if (!id) {
+    return jsonResponse({ error: "ID requis pour la suppression" }, 400);
+  }
+
+  const { error } = await supabase
+    .from("${tableName}")
+    .delete()
+    .eq("id", id);
+
+  if (error) {
+    return jsonResponse({ error: error.message }, 400);
+  }
+
+  return jsonResponse({ success: true });
+}
+`;
+}
+/**
+ * Génère le contenu d'un fichier de migration SQL
+ */
+function generateMigration(tables, slug) {
+    const _timestamp = new Date()
+        .toISOString()
+        .replace(/[-:]/g, "")
+        .split(".")[0]
+        .replace("T", "");
+    const tablesSQL = tables
+        .map((table) => {
+        return `-- ===========================================================================
+-- Table: public.${table.name}
+-- ===========================================================================
+CREATE TABLE IF NOT EXISTS public.${table.name} (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  owner_id uuid NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+  title text NOT NULL,
+  description text,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+-- RLS
+ALTER TABLE public.${table.name} ENABLE ROW LEVEL SECURITY;
+
+-- Politique: Les utilisateurs peuvent voir leurs propres enregistrements
+DROP POLICY IF EXISTS ${table.name}_owner_select ON public.${table.name};
+CREATE POLICY ${table.name}_owner_select ON public.${table.name}
+  FOR SELECT TO authenticated
+  USING (owner_id = auth.uid());
+
+-- Politique: Les utilisateurs peuvent créer leurs propres enregistrements
+DROP POLICY IF EXISTS ${table.name}_owner_insert ON public.${table.name};
+CREATE POLICY ${table.name}_owner_insert ON public.${table.name}
+  FOR INSERT TO authenticated
+  WITH CHECK (owner_id = auth.uid());
+
+-- Politique: Les utilisateurs peuvent modifier leurs propres enregistrements
+DROP POLICY IF EXISTS ${table.name}_owner_update ON public.${table.name};
+CREATE POLICY ${table.name}_owner_update ON public.${table.name}
+  FOR UPDATE TO authenticated
+  USING (owner_id = auth.uid())
+  WITH CHECK (owner_id = auth.uid());
+
+-- Politique: Les utilisateurs peuvent supprimer leurs propres enregistrements
+DROP POLICY IF EXISTS ${table.name}_owner_delete ON public.${table.name};
+CREATE POLICY ${table.name}_owner_delete ON public.${table.name}
+  FOR DELETE TO authenticated
+  USING (owner_id = auth.uid());
+
+-- Trigger updated_at
+DROP TRIGGER IF EXISTS set_${table.name}_updated_at ON public.${table.name};
+CREATE TRIGGER set_${table.name}_updated_at
+  BEFORE UPDATE ON public.${table.name}
+  FOR EACH ROW EXECUTE FUNCTION public.set_updated_at();
+
+-- Index
+CREATE INDEX IF NOT EXISTS idx_${table.name}_owner_id ON public.${table.name}(owner_id);
+
+-- Grants
+GRANT SELECT, INSERT, UPDATE, DELETE ON public.${table.name} TO service_role;
+`;
+    })
+        .join("\n\n");
+    return `-- ${slug} module initial migration
+-- Auto-generated by module-create.ts
+-- NOTE: uses helper function set_updated_at() from base migration
+
+-- ===========================================================================
+-- Helper: set_updated_at trigger function (if not already present)
+-- ===========================================================================
+CREATE OR REPLACE FUNCTION public.set_updated_at()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+BEGIN
+  NEW.updated_at := now();
+  RETURN NEW;
+END;
+$$;
+
+${tablesSQL}
+`;
+}
+/**
+ * Generate Doc.tsx component for the module
+ */
+function generateDocComponent(config) {
+    const moduleNameClean = config.slug.replace("module-", "");
+    const moduleNameOnly = moduleNameClean;
+    // Generate pages sections
+    const publicPages = config.pages.filter((p) => p.section === "public");
+    const authPages = config.pages.filter((p) => p.section === "auth");
+    const adminPages = config.pages.filter((p) => p.section === "admin");
+    let pagesSection = "";
+    if (config.pages.length > 0) {
+        pagesSection = `
+      <Card>
+        <CardHeader>
+          <h2 className="text-2xl font-semibold flex items-center gap-2">
+            <FileText size={24} />
+            Pages Disponibles
+          </h2>
+        </CardHeader>
+        <CardBody className="space-y-4">`;
+        if (publicPages.length > 0) {
+            pagesSection += `
+          <div>
+            <h3 className="text-lg font-semibold mb-2">Pages Publiques</h3>
+            <div className="space-y-2">`;
+            for (const page of publicPages) {
+                const componentName = page.name
+                    .split("-")
+                    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                    .join("");
+                pagesSection += `
+              <div className="flex items-start gap-2">
+                <Chip size="sm" color="success" variant="flat">GET</Chip>
+                <code className="text-sm">${page.path}</code>
+                <span className="text-sm text-slate-600 dark:text-slate-400">- ${componentName}</span>
+              </div>`;
+            }
+            pagesSection += `
+            </div>
+          </div>`;
+        }
+        if (authPages.length > 0) {
+            pagesSection += `
+          <div>
+            <h3 className="text-lg font-semibold mb-2">Pages Protégées (Auth)</h3>
+            <div className="space-y-2">`;
+            for (const page of authPages) {
+                const componentName = page.name
+                    .split("-")
+                    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                    .join("");
+                pagesSection += `
+              <div className="flex items-start gap-2">
+                <Chip size="sm" color="primary" variant="flat">GET</Chip>
+                <code className="text-sm">${page.path}</code>
+                <span className="text-sm text-slate-600 dark:text-slate-400">- ${componentName}</span>
+              </div>`;
+            }
+            pagesSection += `
+            </div>
+          </div>`;
+        }
+        if (adminPages.length > 0) {
+            pagesSection += `
+          <div>
+            <h3 className="text-lg font-semibold mb-2">Pages Admin</h3>
+            <div className="space-y-2">`;
+            for (const page of adminPages) {
+                const componentName = page.name
+                    .split("-")
+                    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                    .join("");
+                pagesSection += `
+              <div className="flex items-start gap-2">
+                <Chip size="sm" color="secondary" variant="flat">GET</Chip>
+                <code className="text-sm">/admin/${moduleNameOnly}/${page.name}</code>
+                <span className="text-sm text-slate-600 dark:text-slate-400">- ${componentName}</span>
+              </div>`;
+            }
+            pagesSection += `
+            </div>
+          </div>`;
+        }
+        pagesSection += `
+        </CardBody>
+      </Card>
+`;
+    }
+    // Generate APIs section
+    let apisSection = "";
+    if (config.tables.length > 0) {
+        apisSection = `
+      <Card>
+        <CardHeader>
+          <h2 className="text-2xl font-semibold flex items-center gap-2">
+            <Zap size={24} />
+            API Routes
+          </h2>
+        </CardHeader>
+        <CardBody className="space-y-4">`;
+        for (const table of config.tables) {
+            for (const section of table.sections) {
+                apisSection += `
+          <div>
+            <h3 className="text-lg font-semibold mb-2">
+              <code>/api/${section}/${table.name}</code>
+            </h3>
+            <div className="flex gap-2">
+              <Chip size="sm" color="success" variant="flat">GET</Chip>
+              <Chip size="sm" color="primary" variant="flat">POST</Chip>
+              <Chip size="sm" color="warning" variant="flat">PUT</Chip>
+              <Chip size="sm" color="danger" variant="flat">DELETE</Chip>
+            </div>
+          </div>`;
+            }
+        }
+        apisSection += `
+        </CardBody>
+      </Card>
+`;
+    }
+    // Generate tables section
+    let tablesSection = "";
+    if (config.tables.length > 0) {
+        tablesSection = `
+      <Card>
+        <CardHeader>
+          <h2 className="text-2xl font-semibold flex items-center gap-2">
+            <Database size={24} />
+            Base de Données
+          </h2>
+        </CardHeader>
+        <CardBody className="space-y-6">`;
+        for (const table of config.tables) {
+            tablesSection += `
+          <TableStructure
+            tableName="${table.name}"
+            title="${table.name}"
+            description="Table ${table.name} du module ${moduleNameClean}"
+          />`;
+        }
+        tablesSection += `
+        </CardBody>
+      </Card>
+`;
+    }
+    // Installation commands
+    const installSection = `
+      <Card>
+        <CardHeader>
+          <h2 className="text-2xl font-semibold flex items-center gap-2">
+            <Package size={24} />
+            Installation
+          </h2>
+        </CardHeader>
+        <CardBody className="space-y-4">
+          <div>
+            <h3 className="text-lg font-semibold mb-2">Ajouter le module</h3>
+            <Snippet symbol="" hideSymbol className="text-sm mb-2">
+              pnpm lastbrain add-module ${moduleNameClean}
+            </Snippet>
+            <Snippet symbol="" hideSymbol className="text-sm mb-2">
+              pnpm build:modules
+            </Snippet>
+          </div>
+          
+          <div>
+            <h3 className="text-lg font-semibold mb-2">Appliquer les migrations</h3>
+            <Snippet symbol="" hideSymbol className="text-sm mb-2">
+              cd apps/votre-app
+            </Snippet>
+            <Snippet symbol="" hideSymbol className="text-sm mb-2">
+              supabase migration up
+            </Snippet>
+          </div>
+        </CardBody>
+      </Card>
+`;
+    // Usage section with placeholder
+    const usageSection = `
+      <Card>
+        <CardHeader>
+          <h2 className="text-2xl font-semibold flex items-center gap-2">
+            <BookOpen size={24} />
+            Utilisation
+          </h2>
+        </CardHeader>
+        <CardBody className="space-y-4">
+          <Alert color="default" className="mb-4">
+            <p className="text-sm">
+              📝 <strong>Section à compléter par l'auteur du module</strong>
+            </p>
+            <p className="text-sm text-slate-600 dark:text-slate-400 mt-2">
+              Ajoutez ici des exemples d'utilisation, des configurations spécifiques,
+              et toute information utile pour les développeurs utilisant ce module.
+            </p>
+          </Alert>
+          
+          <div>
+            <h3 className="text-lg font-semibold mb-2">Exemple d'utilisation</h3>
+            <Alert color="primary" className="p-4 mb-4">
+              <pre className="whitespace-pre-wrap">{\`// Importez les composants depuis le module
+import { ${config.pages.length > 0
+        ? config.pages[0].name
+            .split("-")
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join("") + "Page"
+        : "Component"} } from "${config.moduleName}";
+
+// Utilisez-les dans votre application
+<${config.pages.length > 0
+        ? config.pages[0].name
+            .split("-")
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join("") + "Page"
+        : "Component"} />\`}</pre>
+            </Alert>
+          </div>
+        </CardBody>
+      </Card>
+`;
+    // Danger zone
+    const dangerSection = `
+      <Card>
+        <CardHeader>
+          <h2 className="text-2xl font-semibold flex items-center gap-2 text-danger">
+            <AlertTriangle size={24} />
+            Danger Zone
+          </h2>
+        </CardHeader>
+        <CardBody className="space-y-4">
+          <Alert color="danger" className="mb-4">
+            <p className="text-sm font-semibold">
+              ⚠️ Cette action est irréversible
+            </p>
+            <p className="text-sm mt-2">
+              La suppression du module supprimera toutes les pages, routes API et migrations associées.
+            </p>
+          </Alert>
+          
+          <div>
+            <h3 className="text-lg font-semibold mb-2">Supprimer le module</h3>
+            <Snippet symbol="" hideSymbol color="danger" className="text-sm mb-2">
+              pnpm lastbrain remove-module ${moduleNameClean}
+            </Snippet>
+            <Snippet symbol="" hideSymbol color="danger" className="text-sm mb-2">
+              pnpm build:modules
+            </Snippet>
+          </div>
+        </CardBody>
+      </Card>
+`;
+    return `"use client";
+
+import { Card, CardBody, CardHeader } from "@lastbrain/ui";
+import { Chip } from "@lastbrain/ui";
+import { Snippet } from "@lastbrain/ui";
+import { Alert } from "@lastbrain/ui";
+import { TableStructure } from "@lastbrain/ui";
+import { 
+  FileText, 
+  Zap, 
+  Database, 
+  Package, 
+  BookOpen, 
+  AlertTriangle 
+} from "lucide-react";
+
+/**
+ * Documentation component for ${config.moduleName}
+ * Auto-generated from ${config.slug}.build.config.ts
+ * 
+ * To regenerate this file, run:
+ * pnpm generate:module-docs
+ */
+export function Doc() {
+  return (
+    <div className="container mx-auto p-6 space-y-6">
+      <Card>
+        <CardHeader>
+          <div>
+            <h1 className="text-3xl font-bold mb-2">📦 Module ${moduleNameClean}</h1>
+            <p className="text-slate-600 dark:text-slate-400">${config.moduleName}</p>
+          </div>
+        </CardHeader>
+        <CardBody>
+          <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
+            <div>
+              <p className="text-sm text-slate-600 dark:text-slate-400">Package</p>
+              <code className="text-sm font-semibold">${config.moduleName}</code>
+            </div>
+            <div>
+              <p className="text-sm text-slate-600 dark:text-slate-400">Slug</p>
+              <code className="text-sm font-semibold">${config.slug}</code>
+            </div>
+            <div>
+              <p className="text-sm text-slate-600 dark:text-slate-400">Type</p>
+              <code className="text-sm font-semibold">Module LastBrain</code>
+            </div>
+          </div>
+        </CardBody>
+      </Card>
+${pagesSection}${apisSection}${tablesSection}${installSection}${usageSection}${dangerSection}
+    </div>
+  );
+}
+`;
+}
+/**
+ * Generate README.md for the module
+ */
+async function generateModuleReadme(config, moduleDir) {
+    const moduleNameClean = config.slug.replace("module-", "");
+    let md = `# 📦 Module ${moduleNameClean}\n\n`;
+    md += `> ${config.moduleName}\n\n`;
+    // Description section
+    if (config.description) {
+        md += `## 📝 Description\n\n`;
+        md += `${config.description}\n\n`;
+    }
+    // Information section
+    md += `## 📋 Informations\n\n`;
+    md += `- **Nom du package**: \`${config.moduleName}\`\n`;
+    md += `- **Slug**: \`${config.slug}\`\n`;
+    md += `- **Type**: Module LastBrain\n\n`;
+    // Pages section
+    if (config.pages.length > 0) {
+        md += `## 📄 Pages Disponibles\n\n`;
+        const publicPages = config.pages.filter((p) => p.section === "public");
+        const authPages = config.pages.filter((p) => p.section === "auth");
+        const adminPages = config.pages.filter((p) => p.section === "admin");
+        if (publicPages.length > 0) {
+            md += `### Pages Publiques\n\n`;
+            for (const page of publicPages) {
+                const componentName = page.name
+                    .split("-")
+                    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                    .join("");
+                md += `- **GET** \`${page.path}\` - ${componentName}\n`;
+            }
+            md += `\n`;
+        }
+        if (authPages.length > 0) {
+            md += `### Pages Protégées (Auth)\n\n`;
+            for (const page of authPages) {
+                const componentName = page.name
+                    .split("-")
+                    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                    .join("");
+                md += `- **GET** \`${page.path}\` - ${componentName}\n`;
+            }
+            md += `\n`;
+        }
+        if (adminPages.length > 0) {
+            md += `### Pages Admin\n\n`;
+            for (const page of adminPages) {
+                const componentName = page.name
+                    .split("-")
+                    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                    .join("");
+                md += `- **GET** \`/admin/${config.slug.replace("module-", "")}/${page.name}\` - ${componentName}\n`;
+            }
+            md += `\n`;
+        }
+    }
+    // APIs section
+    if (config.tables.length > 0) {
+        md += `## 🔌 API Routes\n\n`;
+        for (const table of config.tables) {
+            for (const section of table.sections) {
+                md += `### \`/api/${section}/${table.name}\`\n\n`;
+                md += `**Méthodes supportées**: GET, POST, PUT, DELETE\n\n`;
+            }
+        }
+    }
+    // Database section
+    if (config.tables.length > 0) {
+        md += `## 🗄️ Base de Données\n\n`;
+        md += `### Tables\n\n`;
+        for (const table of config.tables) {
+            md += `#### \`${table.name}\`\n\n`;
+            md += `\`\`\`tsx\n`;
+            md += `<TableStructure\n`;
+            md += `  tableName="${table.name}"\n`;
+            md += `  title="${table.name}"\n`;
+            md += `  description="Table ${table.name} du module ${moduleNameClean}"\n`;
+            md += `/>\n`;
+            md += `\`\`\`\n\n`;
+        }
+        // Get migration files
+        const migrationsPath = path.join(moduleDir, "supabase", "migrations");
+        if (fs.existsSync(migrationsPath)) {
+            const migrationFiles = fs
+                .readdirSync(migrationsPath)
+                .filter((f) => f.endsWith(".sql"))
+                .sort();
+            if (migrationFiles.length > 0) {
+                md += `### Migrations\n\n`;
+                for (const migration of migrationFiles) {
+                    md += `- \`${migration}\`\n`;
+                }
+                md += `\n`;
+            }
+        }
+    }
+    // Installation section
+    md += `## 📦 Installation\n\n`;
+    md += `\`\`\`bash\n`;
+    md += `pnpm lastbrain add-module ${moduleNameClean}\n`;
+    md += `pnpm build:modules\n`;
+    md += `\`\`\`\n\n`;
+    md += `### Appliquer les migrations\n\n`;
+    md += `\`\`\`bash\n`;
+    md += `cd apps/votre-app\n`;
+    md += `supabase migration up\n`;
+    md += `\`\`\`\n\n`;
+    // Usage section
+    md += `## 💡 Utilisation\n\n`;
+    md += `<!-- 📝 Section à compléter par l'auteur du module -->\n\n`;
+    md += `### Exemple d'utilisation\n\n`;
+    md += `\`\`\`tsx\n`;
+    md += `// Importez les composants depuis le module\n`;
+    if (config.pages.length > 0) {
+        const firstPage = config.pages[0];
+        const componentName = firstPage.name
+            .split("-")
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join("");
+        md += `import { ${componentName}Page } from "${config.moduleName}";\n\n`;
+        md += `// Utilisez-les dans votre application\n`;
+        md += `<${componentName}Page />\n`;
+    }
+    md += `\`\`\`\n\n`;
+    md += `### Configuration\n\n`;
+    md += `<!-- Ajoutez ici les détails de configuration spécifiques -->\n\n`;
+    // Danger zone
+    md += `## ⚠️ Danger Zone\n\n`;
+    md += `La suppression du module supprimera toutes les pages, routes API et migrations associées. **Cette action est irréversible.**\n\n`;
+    md += `\`\`\`bash\n`;
+    md += `pnpm lastbrain remove-module ${moduleNameClean}\n`;
+    md += `pnpm build:modules\n`;
+    md += `\`\`\`\n\n`;
+    // Write README.md
+    const readmePath = path.join(moduleDir, "README.md");
+    await fs.writeFile(readmePath, md);
+    console.log(chalk.yellow("  📄 README.md"));
+}
+/**
+ * Met à jour le registre des modules dans core/src/config/modules.ts
+ */
+async function updateModuleRegistry(config, rootDir) {
+    const moduleRegistryPath = path.join(rootDir, "packages", "core", "src", "config", "modules.ts");
+    if (!fs.existsSync(moduleRegistryPath)) {
+        console.log(chalk.yellow("  ⚠️  Fichier de registre non trouvé, création..."));
+        // Si le fichier n'existe pas, on le crée avec le module actuel
+        const content = `/**
+ * Configuration centralisée des modules LastBrain
+ * Ce fichier est auto-généré et maintenu par les scripts de gestion des modules
+ */
+
+export interface ModuleMetadata {
+  name: string;
+  package: string;
+  description: string;
+  emoji: string;
+  version?: string;
+}
+
+export const AVAILABLE_MODULES: ModuleMetadata[] = [
+  {
+    name: "${config.slug.replace("module-", "")}",
+    package: "@lastbrain/${config.slug}",
+    description: "Module ${config.moduleName}",
+    emoji: "📦",
+  },
+];
+
+/**
+ * Récupère les métadonnées d'un module par son nom
+ */
+export function getModuleMetadata(name: string): ModuleMetadata | undefined {
+  return AVAILABLE_MODULES.find((m) => m.name === name);
+}
+
+/**
+ * Vérifie si un module existe
+ */
+export function moduleExists(name: string): boolean {
+  return AVAILABLE_MODULES.some((m) => m.name === name);
+}
+
+/**
+ * Récupère la liste des noms de modules disponibles
+ */
+export function getAvailableModuleNames(): string[] {
+  return AVAILABLE_MODULES.map((m) => m.name);
+}
+`;
+        await fs.writeFile(moduleRegistryPath, content, "utf-8");
+        console.log(chalk.green("  ✓ Registre créé"));
+        return;
+    }
+    try {
+        let content = await fs.readFile(moduleRegistryPath, "utf-8");
+        const moduleName = config.slug.replace("module-", "");
+        const moduleEntry = `  {
+    name: "${moduleName}",
+    package: "@lastbrain/${config.slug}",
+    description: "Module ${config.moduleName}",
+    emoji: "📦",
+  },`;
+        // Vérifier si le module existe déjà
+        if (content.includes(`name: "${moduleName}"`)) {
+            console.log(chalk.yellow(`  ⚠️  Module ${moduleName} déjà présent dans le registre`));
+            return;
+        }
+        // Trouver le tableau AVAILABLE_MODULES et ajouter le module
+        const arrayMatch = content.match(/export const AVAILABLE_MODULES: ModuleMetadata\[\] = \[([\s\S]*?)\];/);
+        if (arrayMatch) {
+            const arrayContent = arrayMatch[1];
+            const _lastItem = arrayContent.trim().split("\n").pop();
+            // Ajouter le nouveau module à la fin du tableau
+            const newArrayContent = arrayContent.trimEnd() + "\n" + moduleEntry + "\n";
+            content = content.replace(/export const AVAILABLE_MODULES: ModuleMetadata\[\] = \[([\s\S]*?)\];/, `export const AVAILABLE_MODULES: ModuleMetadata[] = [${newArrayContent}];`);
+            await fs.writeFile(moduleRegistryPath, content, "utf-8");
+            console.log(chalk.green(`  ✓ Module ${moduleName} ajouté au registre`));
+        }
+        else {
+            console.log(chalk.yellow("  ⚠️  Format du registre non reconnu, ajout manuel requis"));
+        }
+    }
+    catch (_error) {
+        console.log(chalk.yellow(`  ⚠️  Erreur lors de la mise à jour du registre: ${_error}`));
+        console.log(chalk.gray("  Vous devrez ajouter manuellement le module au registre"));
+    }
+}
+/**
+ * Trouve le répertoire racine du workspace (avec pnpm-workspace.yaml)
+ */
+export function findWorkspaceRoot() {
+    let rootDir = process.cwd();
+    let attempts = 0;
+    const maxAttempts = 5;
+    while (attempts < maxAttempts) {
+        const workspaceFile = path.join(rootDir, "pnpm-workspace.yaml");
+        if (fs.existsSync(workspaceFile)) {
+            return rootDir;
+        }
+        rootDir = path.resolve(rootDir, "..");
+        attempts++;
+    }
+    throw new Error("Impossible de trouver le répertoire racine du workspace (pnpm-workspace.yaml non trouvé)");
+}
+/**
+ * Crée la structure du module
+ */
+export async function createModuleStructure(config, rootDir) {
+    const moduleDir = path.join(rootDir, "packages", config.slug);
+    console.log(chalk.blue(`\n📦 Création du module ${config.slug}...\n`));
+    // Créer la structure de base
+    await fs.ensureDir(moduleDir);
+    await fs.ensureDir(path.join(moduleDir, "src"));
+    await fs.ensureDir(path.join(moduleDir, "src", "web"));
+    await fs.ensureDir(path.join(moduleDir, "src", "api"));
+    await fs.ensureDir(path.join(moduleDir, "src", "components"));
+    await fs.ensureDir(path.join(moduleDir, "supabase", "migrations"));
+    await fs.ensureDir(path.join(moduleDir, "supabase", "migrations-down"));
+    // Créer package.json
+    console.log(chalk.yellow("  📄 package.json"));
+    await fs.writeFile(path.join(moduleDir, "package.json"), generatePackageJson(config.moduleName, config.slug, rootDir));
+    // Créer tsconfig.json
+    console.log(chalk.yellow("  📄 tsconfig.json"));
+    await fs.writeFile(path.join(moduleDir, "tsconfig.json"), generateTsConfig());
+    // Créer {name}.build.config.ts (sans le préfixe module-)
+    const moduleNameOnly = config.slug.replace("module-", "");
+    const buildConfigFileName = `${moduleNameOnly}.build.config.ts`;
+    console.log(chalk.yellow(`  📄 src/${buildConfigFileName}`));
+    await fs.writeFile(path.join(moduleDir, "src", buildConfigFileName), generateBuildConfig(config));
+    // Créer index.ts
+    console.log(chalk.yellow("  📄 src/index.ts"));
+    await fs.writeFile(path.join(moduleDir, "src", "index.ts"), generateIndexTs(config.pages, moduleNameOnly));
+    // Note: server.ts n'est plus généré pour éviter les conflits d'exports
+    // Les routes API sont exposées via le build.config et l'app les importe dynamiquement
+    // Créer Doc.tsx
+    console.log(chalk.yellow("  📄 src/components/Doc.tsx"));
+    await fs.writeFile(path.join(moduleDir, "src", "components", "Doc.tsx"), generateDocComponent(config));
+    // Créer les pages
+    console.log(chalk.blue("\n📄 Création des pages..."));
+    for (const page of config.pages) {
+        const pagePath = path.join(moduleDir, "src", "web", page.section);
+        await fs.ensureDir(pagePath);
+        const componentName = page.name
+            .split("-")
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join("");
+        const fileName = `${componentName}Page.tsx`;
+        console.log(chalk.yellow(`  📄 src/web/${page.section}/${fileName}`));
+        await fs.writeFile(path.join(pagePath, fileName), generatePageComponent(page.name, page.section));
+    }
+    // Créer les routes API
+    if (config.tables.length > 0) {
+        console.log(chalk.blue("\n🔌 Création des routes API..."));
+        for (const table of config.tables) {
+            for (const section of table.sections) {
+                const apiPath = path.join(moduleDir, "src", "api", section);
+                await fs.ensureDir(apiPath);
+                const fileName = `${table.name}.ts`;
+                console.log(chalk.yellow(`  📄 src/api/${section}/${fileName}`));
+                await fs.writeFile(path.join(apiPath, fileName), generateApiRoute(table.name, section));
+            }
+        }
+    }
+    // Créer les migrations
+    if (config.tables.length > 0) {
+        console.log(chalk.blue("\n🗄️  Création des migrations..."));
+        const timestamp = new Date()
+            .toISOString()
+            .replace(/[-:]/g, "")
+            .split(".")[0]
+            .replace("T", "");
+        const migrationFileName = `${timestamp}_${config.slug}_init.sql`;
+        console.log(chalk.yellow(`  📄 supabase/migrations/${migrationFileName}`));
+        await fs.writeFile(path.join(moduleDir, "supabase", "migrations", migrationFileName), generateMigration(config.tables, config.slug));
+        // Génération du fichier DOWN correspondant pour rollback
+        const downFileName = `${timestamp}_${config.slug}_init.sql`;
+        const downContent = config.tables
+            .map((t) => `-- Rollback for table ${t.name}\nDROP POLICY IF EXISTS ${t.name}_owner_delete ON public.${t.name};\nDROP POLICY IF EXISTS ${t.name}_owner_update ON public.${t.name};\nDROP POLICY IF EXISTS ${t.name}_owner_insert ON public.${t.name};\nDROP POLICY IF EXISTS ${t.name}_owner_select ON public.${t.name};\nDROP TRIGGER IF EXISTS set_${t.name}_updated_at ON public.${t.name};\nDROP INDEX IF EXISTS idx_${t.name}_owner_id;\nDROP TABLE IF EXISTS public.${t.name};\n`)
+            .join("\n");
+        console.log(chalk.yellow(`  📄 supabase/migrations-down/${downFileName}`));
+        await fs.writeFile(path.join(moduleDir, "supabase", "migrations-down", downFileName), `-- DOWN migration for ${config.slug}\n${downContent}`);
+    }
+    // Générer la documentation du module
+    console.log(chalk.blue("\n📝 Génération de la documentation..."));
+    await generateModuleReadme(config, moduleDir);
+    // Installer les dépendances
+    console.log(chalk.blue("\n📦 Installation des dépendances..."));
+    const { execSync } = await import("child_process");
+    const installCmd = process.env.CI
+        ? "pnpm install --no-frozen-lockfile"
+        : "pnpm install";
+    try {
+        execSync(installCmd, {
+            cwd: moduleDir,
+            stdio: "inherit",
+        });
+        console.log(chalk.green("\n✅ Dépendances installées avec succès!"));
+    }
+    catch (_error) {
+        console.log(chalk.yellow("\n⚠️  Erreur lors de l'installation, veuillez exécuter manuellement:"));
+        console.log(chalk.gray(`  cd ${moduleDir} && pnpm install`));
+    }
+    // Mettre à jour le registre des modules dans le core
+    console.log(chalk.blue("\n📝 Mise à jour du registre des modules..."));
+    await updateModuleRegistry(config, rootDir);
+    // Build auto du module pour générer dist immédiatement
+    console.log(chalk.blue("\n🏗️  Build initial du module..."));
+    try {
+        execSync(`pnpm --filter ${config.slug} build`, {
+            cwd: rootDir,
+            stdio: "inherit",
+        });
+        console.log(chalk.green("✓ Module compilé"));
+    }
+    catch (_error) {
+        console.log(chalk.yellow("⚠️  Build automatique échoué, exécutez: cd"), config.slug, "&& pnpm build");
+    }
+    console.log(chalk.green(`\n✅ Module ${config.slug} créé avec succès!\n`));
+    console.log(chalk.gray(`📂 Emplacement: ${moduleDir}\n`));
+    console.log(chalk.blue("Prochaines étapes:"));
+    console.log(chalk.gray(`  1. Ajouter à une app: pnpm lastbrain add-module ${config.slug.replace("module-", "")}`));
+    console.log(chalk.gray("  2. (Optionnel) Modifier Doc.tsx pour documentation personnalisée"));
+    console.log(chalk.gray("  3. Publier: pnpm publish:" + config.slug));
+    console.log(chalk.gray("  4. Générer docs globales: pnpm generate:all\n"));
+}
+/**
+ * Point d'entrée du script
+ */
+export async function createModule() {
+    console.log(chalk.blue("\n🚀 Création d'un nouveau module LastBrain\n"));
+    const answers = await inquirer.prompt([
+        {
+            type: "input",
+            name: "slug",
+            message: "Nom du module (sera préfixé par 'module-'):",
+            validate: (input) => {
+                if (!input || input.trim() === "") {
+                    return "Le nom du module est requis";
+                }
+                if (!/^[a-z0-9-]+$/.test(input)) {
+                    return "Le nom doit contenir uniquement des lettres minuscules, chiffres et tirets";
+                }
+                return true;
+            },
+            filter: (input) => input.trim().toLowerCase(),
+        },
+        {
+            type: "input",
+            name: "description",
+            message: "Description du module (une ligne):",
+            default: "Module LastBrain",
+            validate: (input) => {
+                if (!input || input.trim() === "") {
+                    return "La description est requise";
+                }
+                return true;
+            },
+        },
+        {
+            type: "input",
+            name: "pagesPublic",
+            message: "Pages publiques (séparées par des virgules, ex: legal, privacy, terms):",
+            default: "",
+        },
+        {
+            type: "input",
+            name: "pagesAuth",
+            message: "Pages authentifiées (séparées par des virgules, ex: dashboard, profile):",
+            default: "",
+        },
+        {
+            type: "input",
+            name: "pagesAdmin",
+            message: "Pages admin (séparées par des virgules, ex: settings, users):",
+            default: "",
+        },
+        {
+            type: "input",
+            name: "tables",
+            message: "Tables (séparées par des virgules, ex: settings, notifications):",
+            default: "",
+        },
+    ]);
+    // Construire la configuration du module
+    const slug = `module-${answers.slug}`;
+    const moduleName = `@lastbrain/${slug}`;
+    const description = answers.description;
+    const pages = [];
+    // Pages publiques
+    const publicPages = parsePagesList(answers.pagesPublic);
+    const invalidPublic = publicPages.filter((n) => RESERVED_PAGE_NAMES.has(n));
+    if (invalidPublic.length) {
+        console.error(chalk.red(`❌ Noms de pages publiques réservés détectés: ${invalidPublic.join(", ")}`));
+        console.error(chalk.yellow("Noms interdits: layout, page, api, admin, auth, public. Choisissez des noms métier distincts."));
+        process.exit(1);
+    }
+    for (const pageName of publicPages) {
+        const slugName = slugifyPageName(pageName);
+        pages.push({
+            section: "public",
+            path: `/${slugName}`,
+            name: slugName,
+        });
+    }
+    // Pages auth
+    const authPages = parsePagesList(answers.pagesAuth);
+    const invalidAuth = authPages.filter((n) => RESERVED_PAGE_NAMES.has(n));
+    if (invalidAuth.length) {
+        console.error(chalk.red(`❌ Noms de pages auth réservés détectés: ${invalidAuth.join(", ")}`));
+        console.error(chalk.yellow("Noms interdits: layout, page, api, admin, auth, public. Utilisez des noms métier (ex: dashboard, profile)."));
+        process.exit(1);
+    }
+    for (const pageName of authPages) {
+        const slugName = slugifyPageName(pageName);
+        pages.push({
+            section: "auth",
+            path: `/${slugName}`,
+            name: slugName,
+        });
+    }
+    // Pages admin
+    const adminPages = parsePagesList(answers.pagesAdmin);
+    const invalidAdmin = adminPages.filter((n) => RESERVED_PAGE_NAMES.has(n));
+    if (invalidAdmin.length) {
+        console.error(chalk.red(`❌ Noms de pages admin réservés détectés: ${invalidAdmin.join(", ")}`));
+        console.error(chalk.yellow("Noms interdits: layout, page, api, admin, auth, public. Utilisez des noms métier (ex: settings, users)."));
+        process.exit(1);
+    }
+    for (const pageName of adminPages) {
+        const slugName = slugifyPageName(pageName);
+        pages.push({
+            section: "admin",
+            path: `/${slugName}`,
+            name: slugName,
+        });
+    }
+    // Tables
+    const tableNames = parseTablesList(answers.tables);
+    const tables = [];
+    for (const tableName of tableNames) {
+        // Déterminer dans quelles sections créer les APIs pour cette table
+        const sections = [];
+        if (publicPages.length > 0)
+            sections.push("public");
+        if (authPages.length > 0)
+            sections.push("auth");
+        if (adminPages.length > 0)
+            sections.push("admin");
+        // Si aucune page n'est définie, créer au moins les APIs auth
+        if (sections.length === 0)
+            sections.push("auth");
+        tables.push({
+            name: tableName,
+            sections,
+        });
+    }
+    const config = {
+        slug,
+        moduleName,
+        pages,
+        tables,
+        description,
+    };
+    // Trouver le répertoire racine du workspace (chercher pnpm-workspace.yaml)
+    let rootDir;
+    try {
+        rootDir = findWorkspaceRoot();
+    }
+    catch (_error) {
+        console.error(chalk.red("❌ " + _error.message));
+        process.exit(1);
+    }
+    // Créer le module
+    await createModuleStructure(config, rootDir);
+}
+// Exécuter le script si appelé directement
+if (import.meta.url === `file://${process.argv[1]}`) {
+    createModule().catch((error) => {
+        console.error(chalk.red("❌ Erreur:"), error);
+        process.exit(1);
+    });
+}