@lastbrain/app 0.1.0

package/dist/scripts/module-add.d.ts

@@ -0,0 +1,13 @@
+interface ModuleDefinition {
+    name: string;
+    package: string;
+    displayName: string;
+    description: string;
+    hasMigrations: boolean;
+    migrationsPath?: string;
+    migrationsDownPath?: string;
+}
+export declare const AVAILABLE_MODULES: ModuleDefinition[];
+export declare function addModule(moduleName: string, targetDir: string): Promise<void>;
+export {};
+//# sourceMappingURL=module-add.d.ts.map

package/dist/scripts/module-add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-add.d.ts","sourceRoot":"","sources":["../../src/scripts/module-add.ts"],"names":[],"mappings":"AAMA,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAGD,eAAO,MAAM,iBAAiB,EAAE,gBAAgB,EAsB/C,CAAC;AAEF,wBAAsB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,iBAwMpE"}

package/dist/scripts/module-add.js

@@ -0,0 +1,178 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import { execSync } from "child_process";
+import inquirer from "inquirer";
+// Registre des modules disponibles
+export const AVAILABLE_MODULES = [
+    {
+        name: "auth",
+        package: "@lastbrain/module-auth",
+        displayName: "🔐 Authentication",
+        description: "Système d'authentification complet (signin, signup, sessions)",
+        hasMigrations: true,
+        migrationsPath: "supabase/migrations",
+        migrationsDownPath: "supabase/migrations-down",
+    },
+    {
+        name: "ai",
+        package: "@lastbrain/module-ai",
+        displayName: "🤖 AI Generation",
+        description: "Génération de texte et d'images avec gestion de tokens",
+        hasMigrations: true,
+        migrationsPath: "supabase/migrations",
+        migrationsDownPath: "supabase/migrations-down",
+    },
+    // Ajouter d'autres modules ici au fur et à mesure
+];
+export async function addModule(moduleName, targetDir) {
+    console.log(chalk.blue(`\n🔧 Ajout du module: ${moduleName}\n`));
+    const module = AVAILABLE_MODULES.find((m) => m.name === moduleName);
+    if (!module) {
+        console.error(chalk.red(`❌ Module "${moduleName}" non trouvé. Modules disponibles:`));
+        AVAILABLE_MODULES.forEach((m) => {
+            console.log(chalk.gray(`  - ${m.name}: ${m.description}`));
+        });
+        process.exit(1);
+    }
+    // 1. Vérifier qu'on est dans un projet LastBrain
+    const pkgPath = path.join(targetDir, "package.json");
+    if (!fs.existsSync(pkgPath)) {
+        console.error(chalk.red("❌ package.json non trouvé"));
+        process.exit(1);
+    }
+    const pkg = await fs.readJson(pkgPath);
+    // Vérifier si le module n'est pas déjà installé
+    if (pkg.dependencies?.[module.package] ||
+        pkg.devDependencies?.[module.package]) {
+        console.log(chalk.yellow(`⚠️  Module ${module.package} déjà installé`));
+        return;
+    }
+    // 2. Ajouter la dépendance au package.json
+    console.log(chalk.yellow(`📦 Ajout de ${module.package} aux dépendances...`));
+    pkg.dependencies = pkg.dependencies || {};
+    pkg.dependencies[module.package] = "workspace:*";
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+    // 3. Installer les dépendances
+    console.log(chalk.yellow("📥 Installation des dépendances..."));
+    try {
+        execSync("pnpm install", { cwd: targetDir, stdio: "inherit" });
+    }
+    catch (error) {
+        console.error(chalk.red("❌ Erreur lors de l'installation"));
+        process.exit(1);
+    }
+    // 5. Copier les migrations du module
+    let copiedMigrationFiles = [];
+    if (module.hasMigrations) {
+        console.log(chalk.yellow("\n📋 Copie des migrations du module..."));
+        // Trouver le chemin du module installé
+        const modulePackagePath = path.join(targetDir, "node_modules", ...module.package.split("/"));
+        const moduleMigrationsDir = path.join(modulePackagePath, module.migrationsPath || "supabase/migrations");
+        const projectMigrationsDir = path.join(targetDir, "supabase", "migrations");
+        await fs.ensureDir(projectMigrationsDir);
+        if (fs.existsSync(moduleMigrationsDir)) {
+            const migrationFiles = fs.readdirSync(moduleMigrationsDir);
+            for (const file of migrationFiles) {
+                if (file.endsWith(".sql")) {
+                    const sourcePath = path.join(moduleMigrationsDir, file);
+                    const destPath = path.join(projectMigrationsDir, file);
+                    await fs.copyFile(sourcePath, destPath);
+                    copiedMigrationFiles.push(file);
+                    console.log(chalk.green(`  ✓ ${file}`));
+                }
+            }
+            // 6. Demander comment appliquer les migrations
+            console.log(chalk.yellow("\n🗄️  Application des migrations à la base de données\n"));
+            console.log("Choisissez une option:");
+            console.log(chalk.cyan("  1) 🔄 Reset complet (supabase db reset) - Recommandé en dev"));
+            console.log(chalk.cyan("  2) ⬆️  Push uniquement les nouvelles migrations (supabase migration up)"));
+            console.log(chalk.cyan("  3) ⏭️  Ignorer pour l'instant"));
+            console.log("");
+            const { migrationAction } = await inquirer.prompt([
+                {
+                    type: "rawlist",
+                    name: "migrationAction",
+                    message: "Comment voulez-vous appliquer les migrations ?",
+                    choices: [
+                        {
+                            name: "🔄 Reset complet (supabase db reset) - Recommandé en dev",
+                            value: "reset",
+                        },
+                        {
+                            name: "⬆️  Push uniquement les nouvelles migrations (supabase migration up)",
+                            value: "push",
+                        },
+                        {
+                            name: "⏭️  Ignorer pour l'instant",
+                            value: "skip",
+                        },
+                    ],
+                },
+            ]);
+            if (migrationAction === "reset") {
+                console.log(chalk.yellow("\n🔄 Reset de la base de données..."));
+                try {
+                    execSync("supabase db reset", { cwd: targetDir, stdio: "inherit" });
+                    console.log(chalk.green("✓ Base de données réinitialisée"));
+                }
+                catch (error) {
+                    console.error(chalk.red("❌ Erreur lors du reset"));
+                }
+            }
+            else if (migrationAction === "push") {
+                console.log(chalk.yellow("\n⬆️  Application des nouvelles migrations..."));
+                try {
+                    execSync("supabase migration up", { cwd: targetDir, stdio: "inherit" });
+                    console.log(chalk.green("✓ Migrations appliquées"));
+                }
+                catch (error) {
+                    console.error(chalk.red("❌ Erreur lors de l'application des migrations"));
+                }
+            }
+            else {
+                console.log(chalk.gray("\n⚠️  N'oubliez pas d'appliquer les migrations avec:\n  supabase db reset  ou  supabase migration up\n"));
+            }
+        }
+        else {
+            console.log(chalk.gray("  Aucune migration trouvée pour ce module"));
+        }
+    }
+    // 4. Enregistrer le module dans la configuration
+    const modulesConfigPath = path.join(targetDir, ".lastbrain", "modules.json");
+    await fs.ensureDir(path.dirname(modulesConfigPath));
+    let modulesConfig = { modules: [] };
+    if (fs.existsSync(modulesConfigPath)) {
+        modulesConfig = await fs.readJson(modulesConfigPath);
+    }
+    // Initialiser tous les modules disponibles s'ils n'existent pas
+    for (const availableModule of AVAILABLE_MODULES) {
+        const exists = modulesConfig.modules.find(m => m.package === availableModule.package);
+        if (!exists) {
+            modulesConfig.modules.push({
+                package: availableModule.package,
+                active: false,
+                migrations: [],
+            });
+        }
+    }
+    const existingModuleIndex = modulesConfig.modules.findIndex((m) => m.package === module.package);
+    const migrationsList = copiedMigrationFiles;
+    if (existingModuleIndex >= 0) {
+        modulesConfig.modules[existingModuleIndex] = {
+            package: module.package,
+            active: true,
+            migrations: migrationsList,
+        };
+    }
+    else {
+        modulesConfig.modules.push({
+            package: module.package,
+            active: true,
+            migrations: migrationsList,
+        });
+    }
+    await fs.writeJson(modulesConfigPath, modulesConfig, { spaces: 2 });
+    console.log(chalk.green(`\n✅ Module ${module.displayName} ajouté avec succès!\n`));
+    console.log(chalk.gray("Le serveur de développement redémarrera automatiquement.\n"));
+}

package/dist/scripts/module-build.d.ts

@@ -0,0 +1,2 @@
+export declare function runModuleBuild(): Promise<void>;
+//# sourceMappingURL=module-build.d.ts.map

package/dist/scripts/module-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-build.d.ts","sourceRoot":"","sources":["../../src/scripts/module-build.ts"],"names":[],"mappings":"AAseA,wBAAsB,cAAc,kBAanC"}

package/dist/scripts/module-build.js

@@ -0,0 +1,413 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+// Utiliser PROJECT_ROOT si défini (pour pnpm --filter), sinon process.cwd()
+const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+const appDirectory = path.join(projectRoot, "app");
+// Créer un require dans le contexte de l'application pour résoudre les modules installés dans l'app
+const projectRequire = createRequire(path.join(projectRoot, "package.json"));
+// Charger les modules depuis modules.json
+async function loadModuleConfigs() {
+    const moduleConfigs = [];
+    const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
+    if (!fs.existsSync(modulesJsonPath)) {
+        return moduleConfigs;
+    }
+    try {
+        const modulesData = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
+        const modules = modulesData.modules || [];
+        for (const module of modules) {
+            // Ne charger que les modules actifs
+            if (module.active === false) {
+                continue;
+            }
+            const packageName = module.package;
+            try {
+                const moduleSuffix = packageName.replace("@lastbrain/module-", "");
+                const possibleConfigNames = [
+                    `${moduleSuffix}.build.config`,
+                    "build.config",
+                ];
+                let loaded = false;
+                for (const configName of possibleConfigNames) {
+                    try {
+                        // Résoudre le chemin du module depuis l'application
+                        const modulePath = projectRequire.resolve(`${packageName}/${configName}`);
+                        // Convertir en URL file:// pour l'import dynamique
+                        const moduleUrl = `file://${modulePath}`;
+                        const moduleImport = await import(moduleUrl);
+                        if (moduleImport.default) {
+                            moduleConfigs.push(moduleImport.default);
+                            loaded = true;
+                            break;
+                        }
+                    }
+                    catch (err) {
+                        // Essayer le nom suivant
+                    }
+                }
+                if (!loaded) {
+                    console.warn(`⚠️  Could not load build config for ${packageName}`);
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️  Failed to load module ${packageName}:`, error);
+            }
+        }
+    }
+    catch (error) {
+        console.error("❌ Error loading modules.json:", error);
+    }
+    return moduleConfigs;
+}
+const sectionDirectoryMap = {
+    public: ["(public)"],
+    auth: ["auth"],
+    admin: ["admin"],
+    user: ["auth", "user"],
+};
+const sectionLayoutMap = {
+    auth: "AuthLayout",
+    admin: "AdminLayout",
+    "(public)": "PublicLayout",
+};
+const generatedSections = new Set();
+const navigation = {
+    public: [],
+    auth: [],
+    admin: [],
+};
+const userMenu = [];
+function ensureDirectory(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function ensureSectionLayout(sectionPath) {
+    const sectionDir = path.join(appDirectory, ...sectionPath);
+    const sectionKey = sectionPath[0];
+    // Éviter de générer plusieurs fois le même layout
+    if (generatedSections.has(sectionKey)) {
+        return;
+    }
+    ensureDirectory(sectionDir);
+    const layoutName = sectionLayoutMap[sectionKey];
+    if (layoutName) {
+        const layoutPath = path.join(sectionDir, "layout.tsx");
+        if (!fs.existsSync(layoutPath)) {
+            const layoutContent = `import { ${layoutName} } from "@lastbrain/app";
+
+export default function SectionLayout({ children }: { children: React.ReactNode }) {
+  return <${layoutName}>{children}</${layoutName}>;
+}
+`;
+            fs.writeFileSync(layoutPath, layoutContent);
+            console.log(`📐 Generated section layout: ${layoutPath}`);
+        }
+    }
+    generatedSections.add(sectionKey);
+}
+function toPascalCase(value) {
+    return value
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map((segment) => segment[0].toUpperCase() + segment.slice(1))
+        .join("");
+}
+function buildPage(moduleConfig, page) {
+    const segments = page.path.replace(/^\/+/, "").split("/").filter(Boolean);
+    const sectionPath = sectionDirectoryMap[page.section] ?? ["(public)"];
+    // Générer le layout de section si nécessaire
+    ensureSectionLayout(sectionPath);
+    const routeDir = path.join(appDirectory, ...sectionPath, ...segments);
+    const filePath = path.join(routeDir, "page.tsx");
+    ensureDirectory(routeDir);
+    const wrapperSuffix = segments.length
+        ? toPascalCase(segments.join("-"))
+        : "Root";
+    const wrapperName = `${page.componentExport}${wrapperSuffix}Route`;
+    // Vérifier si la route a des paramètres dynamiques (segments avec [])
+    const hasDynamicParams = segments.some(seg => seg.startsWith('[') && seg.endsWith(']'));
+    // Pour les pages publiques (signin, signup, etc.), utiliser dynamic import sans SSR
+    // pour éviter les erreurs d'hydratation avec les IDs HeroUI/React Aria
+    const isPublicAuthPage = page.section === "public" &&
+        (page.path.includes("signin") || page.path.includes("signup") || page.path.includes("reset-password"));
+    let content;
+    if (isPublicAuthPage) {
+        content = `"use client";
+
+import dynamic from "next/dynamic";
+
+const ${page.componentExport} = dynamic(
+  () => import("${moduleConfig.moduleName}").then((mod) => ({ default: mod.${page.componentExport} })),
+  { ssr: false }
+);
+
+export default function ${wrapperName}${hasDynamicParams ? '(props: any)' : '()'} {
+  return <${page.componentExport} ${hasDynamicParams ? '{...props}' : ''} />;
+}
+`;
+    }
+    else {
+        content = `import { ${page.componentExport} } from "${moduleConfig.moduleName}";
+
+export default function ${wrapperName}${hasDynamicParams ? '(props: any)' : '()'} {
+  return <${page.componentExport} ${hasDynamicParams ? '{...props}' : ''} />;
+}
+`;
+    }
+    fs.writeFileSync(filePath, content);
+    console.log(`⭐ Generated page: ${filePath}`);
+    const entry = {
+        label: `Module:${moduleConfig.moduleName} ${page.componentExport}`,
+        path: page.path,
+        module: moduleConfig.moduleName,
+        section: page.section,
+    };
+    if (page.section === "user") {
+        userMenu.push(entry);
+    }
+    else if (page.section) {
+        navigation[page.section]?.push(entry);
+    }
+}
+function buildApi(moduleConfig, api) {
+    const segments = api.path.replace(/^\/+/, "").split("/").filter(Boolean);
+    const sanitizedSegments = segments[0] === "api" ? segments.slice(1) : segments;
+    const routeDir = path.join(appDirectory, "api", ...sanitizedSegments);
+    const filePath = path.join(routeDir, "route.ts");
+    ensureDirectory(routeDir);
+    const handler = `${moduleConfig.moduleName}/${api.entryPoint}`;
+    const content = `export { ${api.handlerExport} } from "${handler}";
+`;
+    fs.writeFileSync(filePath, content);
+    console.log(`🔌 Generated API route: ${filePath}`);
+}
+function dumpNavigation() {
+    const navPath = path.join(appDirectory, "navigation.generated.ts");
+    const content = `export type MenuEntry = { label: string; path: string; module: string; section: string };
+
+export const navigation = ${JSON.stringify(navigation, null, 2)};
+
+export const userMenu = ${JSON.stringify(userMenu, null, 2)};
+`;
+    fs.writeFileSync(navPath, content);
+    console.log(`🧭 Generated navigation metadata: ${navPath}`);
+}
+/**
+ * Génère le fichier config/menu.ts à partir des configurations de menu des modules
+ */
+function generateMenuConfig(moduleConfigs) {
+    const configDir = path.join(projectRoot, "config");
+    ensureDirectory(configDir);
+    const menuPath = path.join(configDir, "menu.ts");
+    // Collecter les menus de tous les modules
+    const publicMenus = [];
+    const authMenus = [];
+    const adminMenus = [];
+    const accountMenus = [];
+    moduleConfigs.forEach((moduleConfig) => {
+        if (moduleConfig.menu) {
+            if (moduleConfig.menu.public) {
+                publicMenus.push(...moduleConfig.menu.public);
+            }
+            if (moduleConfig.menu.auth) {
+                authMenus.push(...moduleConfig.menu.auth);
+            }
+            if (moduleConfig.menu.admin) {
+                adminMenus.push(...moduleConfig.menu.admin);
+            }
+            if (moduleConfig.menu.account) {
+                accountMenus.push(...moduleConfig.menu.account);
+            }
+        }
+    });
+    // Trier par ordre
+    const sortByOrder = (a, b) => {
+        return (a.order ?? 999) - (b.order ?? 999);
+    };
+    publicMenus.sort(sortByOrder);
+    authMenus.sort(sortByOrder);
+    adminMenus.sort(sortByOrder);
+    accountMenus.sort(sortByOrder);
+    // Générer le contenu du fichier
+    const content = `// Auto-generated menu configuration
+// Generated from module build configs
+
+export interface MenuItem {
+  title: string;
+  description?: string;
+  icon?: string;
+  path: string;
+  order?: number;
+}
+
+export interface MenuConfig {
+  public: MenuItem[];
+  auth: MenuItem[];
+  admin: MenuItem[];
+  account: MenuItem[];
+}
+
+export const menuConfig: MenuConfig = {
+  public: ${JSON.stringify(publicMenus, null, 2)},
+  auth: ${JSON.stringify(authMenus, null, 2)},
+  admin: ${JSON.stringify(adminMenus, null, 2)},
+  account: ${JSON.stringify(accountMenus, null, 2)},
+};
+`;
+    fs.writeFileSync(menuPath, content);
+    console.log(`🍔 Generated menu configuration: ${menuPath}`);
+}
+function copyModuleMigrations(moduleConfigs) {
+    const supabaseMigrationsDir = path.join(projectRoot, "supabase", "migrations");
+    // S'assurer que le dossier migrations existe
+    if (!fs.existsSync(supabaseMigrationsDir)) {
+        ensureDirectory(supabaseMigrationsDir);
+    }
+    const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
+    // Charger modules.json
+    let modulesConfig = { modules: [] };
+    if (fs.existsSync(modulesJsonPath)) {
+        modulesConfig = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
+    }
+    moduleConfigs.forEach((moduleConfig) => {
+        try {
+            const moduleName = moduleConfig.moduleName;
+            const copiedMigrations = [];
+            // Essayer plusieurs chemins possibles pour trouver le module
+            const possiblePaths = [
+                // Dans node_modules local de l'app
+                path.join(projectRoot, "node_modules", moduleName),
+                // Dans node_modules à la racine du workspace
+                path.join(projectRoot, "..", "..", "node_modules", moduleName),
+                // Directement dans packages/ (pour monorepo)
+                path.join(projectRoot, "..", "..", "packages", moduleName.replace("@lastbrain/", "")),
+            ];
+            let moduleBasePath = null;
+            for (const possiblePath of possiblePaths) {
+                if (fs.existsSync(possiblePath)) {
+                    moduleBasePath = possiblePath;
+                    break;
+                }
+            }
+            if (!moduleBasePath) {
+                return;
+            }
+            const moduleMigrationsDir = path.join(moduleBasePath, "supabase", "migrations");
+            if (fs.existsSync(moduleMigrationsDir)) {
+                const migrationFiles = fs.readdirSync(moduleMigrationsDir);
+                migrationFiles.forEach((file) => {
+                    if (file.endsWith(".sql")) {
+                        const sourcePath = path.join(moduleMigrationsDir, file);
+                        const destPath = path.join(supabaseMigrationsDir, file);
+                        // Copier seulement si le fichier n'existe pas déjà
+                        if (!fs.existsSync(destPath)) {
+                            fs.copyFileSync(sourcePath, destPath);
+                            console.log(`📦 Copied migration: ${file} from ${moduleName}`);
+                        }
+                        copiedMigrations.push(file);
+                    }
+                });
+            }
+            // Mettre à jour modules.json avec les migrations
+            if (copiedMigrations.length > 0) {
+                const moduleIndex = modulesConfig.modules.findIndex((m) => m.package === moduleName);
+                if (moduleIndex >= 0) {
+                    modulesConfig.modules[moduleIndex].migrations = copiedMigrations;
+                }
+                else {
+                    modulesConfig.modules.push({
+                        package: moduleName,
+                        migrations: copiedMigrations,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️  Could not copy migrations from ${moduleConfig.moduleName}:`, error);
+        }
+    });
+    // Sauvegarder modules.json avec les migrations mises à jour
+    ensureDirectory(path.dirname(modulesJsonPath));
+    fs.writeFileSync(modulesJsonPath, JSON.stringify(modulesConfig, null, 2));
+}
+function generateDocsPage(moduleConfigs) {
+    const docsDir = path.join(appDirectory, "docs");
+    ensureDirectory(docsDir);
+    const docsPagePath = path.join(docsDir, "page.tsx");
+    // Charger tous les modules depuis modules.json (actifs ET inactifs)
+    const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
+    let allModules = [];
+    if (fs.existsSync(modulesJsonPath)) {
+        try {
+            const modulesData = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
+            allModules = modulesData.modules || [];
+        }
+        catch (error) {
+            console.error("❌ Error reading modules.json:", error);
+        }
+    }
+    // Générer les imports des composants Doc de chaque module
+    const docImports = [];
+    const moduleConfigurations = [];
+    allModules.forEach((moduleEntry) => {
+        const moduleName = moduleEntry.package;
+        const moduleId = moduleName.replace("@lastbrain/module-", "");
+        const docComponentName = `${toPascalCase(moduleId)}ModuleDoc`;
+        // Trouver la config du module pour obtenir la description
+        const moduleConfig = moduleConfigs.find(mc => mc.moduleName === moduleName);
+        const description = moduleConfig ? getModuleDescription(moduleConfig) : "Module non configuré";
+        // Importer le composant Doc seulement pour les modules actifs
+        if (moduleEntry.active) {
+            docImports.push(`import { ${docComponentName} } from "${moduleName}";`);
+        }
+        const config = {
+            id: moduleId,
+            name: `Module ${moduleId.charAt(0).toUpperCase() + moduleId.slice(1)}`,
+            description: description,
+            component: docComponentName,
+            active: moduleEntry.active,
+        };
+        moduleConfigurations.push(`  {
+    id: "${config.id}",
+    name: "${config.name}",
+    description: "${config.description}",
+    ${config.active ? `content: <${config.component} />,` : 'content: null,'}
+    available: ${config.active},
+  }`);
+    });
+    const docsContent = `// Auto-generated docs page with module documentation
+import React from "react";
+import { DocPage } from "@lastbrain/app";
+${docImports.join('\n')}
+
+export default function DocsPage() {
+  const modules = [
+${moduleConfigurations.join(',\n')}
+  ];
+  
+  return <DocPage modules={modules} />;
+}
+`;
+    fs.writeFileSync(docsPagePath, docsContent);
+    console.log(`📚 Generated docs page: ${docsPagePath}`);
+}
+function getModuleDescription(moduleConfig) {
+    // Essayer de déduire la description depuis les pages ou retourner une description par défaut
+    if (moduleConfig.pages.length > 0) {
+        return `${moduleConfig.pages.length} page(s), ${moduleConfig.apis.length} API(s)`;
+    }
+    return "Module documentation";
+}
+export async function runModuleBuild() {
+    ensureDirectory(appDirectory);
+    const moduleConfigs = await loadModuleConfigs();
+    moduleConfigs.forEach((moduleConfig) => {
+        moduleConfig.pages.forEach((page) => buildPage(moduleConfig, page));
+        moduleConfig.apis.forEach((api) => buildApi(moduleConfig, api));
+    });
+    dumpNavigation();
+    generateMenuConfig(moduleConfigs);
+    generateDocsPage(moduleConfigs);
+    copyModuleMigrations(moduleConfigs);
+}
+runModuleBuild();

package/dist/scripts/module-create.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Point d'entrée du script
+ */
+export declare function createModule(): Promise<void>;
+//# sourceMappingURL=module-create.d.ts.map

package/dist/scripts/module-create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-create.d.ts","sourceRoot":"","sources":["../../src/scripts/module-create.ts"],"names":[],"mappings":"AAupBA;;GAEG;AACH,wBAAsB,YAAY,kBAsIjC"}