@lastbrain/app 2.0.1 → 2.0.2

package/dist/src/scripts/module-delete.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Supprime un module du monorepo (physiquement)
+ * Cette commande est réservée aux développeurs du framework
+ */
+export declare function deleteModule(): Promise<void>;
+//# sourceMappingURL=module-delete.d.ts.map

package/dist/src/scripts/module-delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-delete.d.ts","sourceRoot":"","sources":["../../../src/scripts/module-delete.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,wBAAsB,YAAY,kBAkLjC"}

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

@@ -0,0 +1,147 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { fileURLToPath } from "url";
+import { AVAILABLE_MODULES } from "@lastbrain/core/config/modules";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Supprime un module du monorepo (physiquement)
+ * Cette commande est réservée aux développeurs du framework
+ */
+export async function deleteModule() {
+    const rootDir = path.resolve(__dirname, "../../../..");
+    console.log(chalk.blue("\n🗑️  Suppression d'un module du monorepo LastBrain\n"));
+    console.log(chalk.yellow("⚠️  ATTENTION: Cette opération supprime physiquement le module du monorepo!"));
+    console.log(chalk.gray("Cette commande est réservée aux développeurs du framework.\n"));
+    // Lister les modules disponibles
+    if (AVAILABLE_MODULES.length === 0) {
+        console.log(chalk.red("❌ Aucun module disponible dans le registre"));
+        process.exit(1);
+    }
+    const answers = await inquirer.prompt([
+        {
+            type: "select",
+            name: "moduleName",
+            message: "Quel module voulez-vous supprimer du monorepo ?",
+            choices: AVAILABLE_MODULES.map((m) => ({
+                name: `${m.emoji} ${m.name} - ${m.description}`,
+                value: m.name,
+            })),
+        },
+        {
+            type: "confirm",
+            name: "confirm",
+            message: (answers) => `Êtes-vous sûr de vouloir supprimer le module "${answers.moduleName}" ? Cette action est irréversible.`,
+            default: false,
+        },
+    ]);
+    if (!answers.confirm) {
+        console.log(chalk.gray("\n❌ Opération annulée"));
+        process.exit(0);
+    }
+    const moduleName = answers.moduleName;
+    const moduleMeta = AVAILABLE_MODULES.find((m) => m.name === moduleName);
+    if (!moduleMeta) {
+        console.log(chalk.red(`❌ Module ${moduleName} non trouvé`));
+        process.exit(1);
+    }
+    console.log(chalk.blue(`\n🗑️  Suppression du module ${moduleMeta.package}...\n`));
+    // 1. Supprimer le répertoire du module
+    // Extraire le nom du package correctement (gérer @lastbrain et @lastbrain-labs)
+    const packageName = moduleMeta.package
+        .replace("@lastbrain-labs/", "")
+        .replace("@lastbrain/", "");
+    const moduleDir = path.join(rootDir, "packages", packageName);
+    if (fs.existsSync(moduleDir)) {
+        console.log(chalk.yellow(`📁 Suppression du répertoire: ${moduleDir}`));
+        await fs.remove(moduleDir);
+        console.log(chalk.green("  ✓ Répertoire supprimé"));
+    }
+    else {
+        console.log(chalk.yellow(`  ⚠️  Répertoire non trouvé: ${moduleDir}`));
+    }
+    // 2. Supprimer du registre central
+    console.log(chalk.yellow("\n📝 Mise à jour du registre central..."));
+    const moduleRegistryPath = path.join(rootDir, "packages", "core", "src", "config", "modules.ts");
+    if (fs.existsSync(moduleRegistryPath)) {
+        try {
+            let content = await fs.readFile(moduleRegistryPath, "utf-8");
+            // Vérifier si le module est dans le registre
+            if (!content.includes(`name: "${moduleName}"`)) {
+                console.log(chalk.yellow(`  ⚠️  Module ${moduleName} n'est pas dans le registre`));
+            }
+            else {
+                // Parser et reconstruire le tableau proprement
+                const arrayMatch = content.match(/export const AVAILABLE_MODULES: ModuleMetadata\[\] = \[([\s\S]*?)\];/);
+                if (arrayMatch) {
+                    const arrayContent = arrayMatch[1];
+                    const modules = [];
+                    let currentModule = "";
+                    let braceDepth = 0;
+                    // Parser chaque module
+                    for (const line of arrayContent.split("\n")) {
+                        if (line.trim().startsWith("{")) {
+                            braceDepth++;
+                        }
+                        currentModule += line + "\n";
+                        if (line.includes("},")) {
+                            braceDepth--;
+                            if (braceDepth === 0) {
+                                // Module complet trouvé
+                                if (!currentModule.includes(`name: "${moduleName}"`)) {
+                                    modules.push(currentModule.trim());
+                                }
+                                currentModule = "";
+                            }
+                        }
+                    }
+                    // Reconstruire le tableau
+                    const newArrayContent = modules.length > 0 ? "\n  " + modules.join("\n  ") + "\n" : "\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} supprimé du registre`));
+                }
+                else {
+                    console.log(chalk.yellow("  ⚠️  Format du registre non reconnu"));
+                }
+            }
+        }
+        catch (error) {
+            console.log(chalk.red(`  ❌ Erreur lors de la mise à jour du registre: ${error}`));
+        }
+    }
+    // 3. Supprimer des scripts de publication
+    console.log(chalk.yellow("\n📝 Mise à jour du package.json racine..."));
+    const rootPackageJson = path.join(rootDir, "package.json");
+    if (fs.existsSync(rootPackageJson)) {
+        try {
+            const pkg = await fs.readJson(rootPackageJson);
+            const publishScript = `publish:${moduleName}`;
+            if (pkg.scripts && pkg.scripts[publishScript]) {
+                delete pkg.scripts[publishScript];
+                await fs.writeJson(rootPackageJson, pkg, { spaces: 2 });
+                console.log(chalk.green(`  ✓ Script de publication supprimé`));
+            }
+            else {
+                console.log(chalk.gray(`  ℹ️  Aucun script de publication trouvé`));
+            }
+        }
+        catch (error) {
+            console.log(chalk.yellow(`  ⚠️  Erreur lors de la mise à jour: ${error}`));
+        }
+    }
+    console.log(chalk.green(`\n✅ Module ${moduleName} supprimé avec succès!\n`));
+    console.log(chalk.yellow("Prochaines étapes:"));
+    console.log(chalk.gray("  1. cd packages/core && pnpm build"));
+    console.log(chalk.gray("  2. Vérifier les projets qui utilisaient ce module"));
+    console.log(chalk.gray("  3. Commiter les changements\n"));
+}
+// Point d'entrée CLI
+if (import.meta.url === `file://${process.argv[1]}`) {
+    deleteModule().catch((error) => {
+        console.error(chalk.red("\n❌ Erreur:"), error);
+        process.exit(1);
+    });
+}

package/dist/src/scripts/module-list.d.ts

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

package/dist/src/scripts/module-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-list.d.ts","sourceRoot":"","sources":["../../../src/scripts/module-list.ts"],"names":[],"mappings":"AAKA,wBAAsB,WAAW,CAAC,SAAS,EAAE,MAAM,iBAwElD"}

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

@@ -0,0 +1,61 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import { AVAILABLE_MODULES } from "@lastbrain/core/config/modules";
+export async function listModules(targetDir) {
+    console.log(chalk.blue("\n📦 Modules disponibles:\n"));
+    // Lire la config des modules installés
+    const modulesConfigPath = path.join(targetDir, ".lastbrain", "modules.json");
+    let installedPackages = [];
+    let inactivePackages = [];
+    if (fs.existsSync(modulesConfigPath)) {
+        const modulesConfig = await fs.readJson(modulesConfigPath);
+        const modules = modulesConfig.modules || [];
+        // Supporte deux formats:
+        // - Ancien: string[] des noms de packages
+        // - Actuel: { package: string; active?: boolean; migrations?: string[] }[]
+        if (Array.isArray(modules)) {
+            if (modules.length > 0 && typeof modules[0] === "string") {
+                installedPackages = modules;
+            }
+            else {
+                const entries = modules;
+                installedPackages = entries
+                    .filter((m) => m && m.package && m.active !== false)
+                    .map((m) => m.package);
+                inactivePackages = entries
+                    .filter((m) => m && m.package && m.active === false)
+                    .map((m) => m.package);
+            }
+        }
+    }
+    // Afficher tous les modules disponibles
+    AVAILABLE_MODULES.forEach((module) => {
+        const isInstalled = installedPackages.includes(module.package);
+        const isInactive = inactivePackages.includes(module.package);
+        const status = isInstalled
+            ? chalk.green("✓ installé")
+            : isInactive
+                ? chalk.yellow("⤳ inactif")
+                : chalk.gray("  disponible");
+        console.log(chalk.bold(`${module.emoji} ${module.name.charAt(0).toUpperCase() + module.name.slice(1)}`));
+        console.log(chalk.gray(`  Nom: ${module.name}`));
+        console.log(chalk.gray(`  Package: ${module.package}`));
+        console.log(chalk.gray(`  Description: ${module.description}`));
+        console.log(`  Statut: ${status}`);
+        // Afficher la commande appropriée selon le statut
+        if (isInstalled) {
+            console.log(chalk.cyan(`  → pnpm lastbrain remove-module ${module.name}`));
+        }
+        else if (isInactive || !isInstalled) {
+            console.log(chalk.cyan(`  → pnpm lastbrain add-module ${module.name}`));
+        }
+        console.log();
+    });
+    console.log(chalk.gray("─".repeat(50)));
+    console.log(chalk.gray("\nCommandes disponibles:"));
+    console.log(chalk.cyan("  pnpm lastbrain add-module <nom>    ") +
+        chalk.gray("- Ajouter un module"));
+    console.log(chalk.cyan("  pnpm lastbrain remove-module <nom> ") +
+        chalk.gray("- Supprimer un module\n"));
+}

package/dist/src/scripts/module-remove.d.ts

@@ -0,0 +1,2 @@
+export declare function removeModule(moduleName: string, targetDir: string): Promise<void>;
+//# sourceMappingURL=module-remove.d.ts.map

package/dist/src/scripts/module-remove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-remove.d.ts","sourceRoot":"","sources":["../../../src/scripts/module-remove.ts"],"names":[],"mappings":"AA6FA,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,iBA4WvE"}

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

@@ -0,0 +1,311 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import { execSync } from "child_process";
+import inquirer from "inquirer";
+import { AVAILABLE_MODULES, } from "@lastbrain/core/config/modules";
+// Convert core module metadata to local module definition
+function toModuleDefinition(meta) {
+    return {
+        name: meta.name,
+        package: meta.package,
+        displayName: `${meta.emoji} ${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`,
+        description: meta.description,
+        hasMigrations: true,
+        migrationsPath: "supabase/migrations",
+        migrationsDownPath: "supabase/migrations-down",
+    };
+}
+async function removeGeneratedFiles(moduleName, modulePackage, targetDir) {
+    console.log(chalk.yellow("\n🗑️  Suppression des pages générées..."));
+    const appDirectory = path.join(targetDir, "app");
+    if (!fs.existsSync(appDirectory)) {
+        return;
+    }
+    // Fonction récursive pour trouver les fichiers
+    async function findAndRemoveFiles(dir) {
+        if (!fs.existsSync(dir))
+            return;
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await findAndRemoveFiles(fullPath);
+            }
+            else if (entry.name === "page.tsx" || entry.name === "route.ts") {
+                try {
+                    const content = await fs.readFile(fullPath, "utf-8");
+                    // Vérifier si le fichier importe depuis le module (y compris sous-chemins)
+                    if (content.includes(`"${modulePackage}`) ||
+                        content.includes(`'${modulePackage}`)) {
+                        await fs.remove(fullPath);
+                        console.log(chalk.gray(`  ✓ Supprimé ${path.relative(targetDir, fullPath)}`));
+                        // Supprimer le dossier parent si vide
+                        const parentDir = path.dirname(fullPath);
+                        const remainingFiles = await fs.readdir(parentDir);
+                        if (remainingFiles.length === 0) {
+                            await fs.remove(parentDir);
+                        }
+                    }
+                }
+                catch {
+                    // Ignorer les erreurs de lecture
+                }
+            }
+        }
+    }
+    await findAndRemoveFiles(appDirectory);
+    // Supprimer le fichier navigation.generated.ts pour qu'il soit regénéré au prochain build
+    const navPath = path.join(appDirectory, "navigation.generated.ts");
+    if (fs.existsSync(navPath)) {
+        await fs.remove(navPath);
+        console.log(chalk.gray("  ✓ Navigation réinitialisée"));
+    }
+}
+export async function removeModule(moduleName, targetDir) {
+    console.log(chalk.blue(`\n🗑️  Suppression du module: ${moduleName}\n`));
+    const moduleMeta = AVAILABLE_MODULES.find((m) => m.name === moduleName);
+    if (!moduleMeta) {
+        console.error(chalk.red(`❌ Module "${moduleName}" non trouvé. Modules disponibles:`));
+        AVAILABLE_MODULES.forEach((m) => {
+            console.log(chalk.gray(`  - ${m.emoji} ${m.name}: ${m.description}`));
+        });
+        process.exit(1);
+    }
+    const module = toModuleDefinition(moduleMeta);
+    // 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 est installé (dans package.json OU modules.json)
+    const modulesConfigPath = path.join(targetDir, ".lastbrain", "modules.json");
+    let isInstalledInConfig = false;
+    if (fs.existsSync(modulesConfigPath)) {
+        const modulesConfig = await fs.readJson(modulesConfigPath);
+        isInstalledInConfig = modulesConfig.modules?.includes(module.package);
+    }
+    const isInstalledInPackage = pkg.dependencies?.[module.package] || pkg.devDependencies?.[module.package];
+    if (!isInstalledInPackage && !isInstalledInConfig) {
+        console.log(chalk.yellow(`⚠️  Module ${module.package} n'est pas installé`));
+        return;
+    }
+    // 2. Retirer la dépendance du package.json
+    console.log(chalk.yellow(`📦 Suppression de ${module.package} des dépendances...`));
+    if (pkg.dependencies?.[module.package]) {
+        delete pkg.dependencies[module.package];
+    }
+    if (pkg.devDependencies?.[module.package]) {
+        delete pkg.devDependencies[module.package];
+    }
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+    // 3. Retirer de la configuration
+    if (fs.existsSync(modulesConfigPath)) {
+        const modulesConfig = await fs.readJson(modulesConfigPath);
+        modulesConfig.modules = modulesConfig.modules.filter((m) => m !== module.package);
+        await fs.writeJson(modulesConfigPath, modulesConfig, { spaces: 2 });
+    }
+    // 3.5 Supprimer les pages/APIs générées
+    await removeGeneratedFiles(module.name, module.package, targetDir);
+    // 4. Gérer les migrations
+    if (module.hasMigrations) {
+        console.log(chalk.yellow("\n🗄️  Gestion des migrations du module\n"));
+        const projectMigrationsDir = path.join(targetDir, "supabase", "migrations");
+        // Récupérer la liste des migrations depuis modules.json
+        const modulesConfigPath = path.join(targetDir, ".lastbrain", "modules.json");
+        let migrationFiles = [];
+        if (fs.existsSync(modulesConfigPath)) {
+            const modulesConfig = await fs.readJson(modulesConfigPath);
+            const moduleEntry = modulesConfig.modules.find((m) => (typeof m === "string" ? m : m.package) === module.package);
+            if (moduleEntry &&
+                typeof moduleEntry === "object" &&
+                moduleEntry.migrations) {
+                migrationFiles = moduleEntry.migrations;
+                console.log(chalk.gray(`DEBUG: Migrations from config: ${migrationFiles.join(", ")}`));
+            }
+        }
+        // Fallback: essayer de lire depuis node_modules si disponible
+        if (migrationFiles.length === 0) {
+            const modulePackagePath = path.join(targetDir, "node_modules", ...module.package.split("/"));
+            const moduleMigrationsDir = path.join(modulePackagePath, module.migrationsPath || "supabase/migrations");
+            if (fs.existsSync(moduleMigrationsDir)) {
+                migrationFiles = fs
+                    .readdirSync(moduleMigrationsDir)
+                    .filter((f) => f.endsWith(".sql"));
+                console.log(chalk.gray(`DEBUG: Found ${migrationFiles.length} migration files from node_modules: ${migrationFiles.join(", ")}`));
+            }
+            else {
+                console.log(chalk.gray(`DEBUG: No migrations found in config or node_modules`));
+            }
+        }
+        // Trouver le chemin du module pour les migrations down
+        const modulePackagePath = path.join(targetDir, "node_modules", ...module.package.split("/"));
+        const moduleMigrationsDownDir = path.join(modulePackagePath, module.migrationsDownPath || "supabase/migrations-down");
+        let hasDownMigrations = false;
+        // Vérifier si des fichiers down existent dans le dossier séparé
+        if (fs.existsSync(moduleMigrationsDownDir)) {
+            hasDownMigrations = fs
+                .readdirSync(moduleMigrationsDownDir)
+                .some((f) => f.endsWith(".sql"));
+        }
+        const choices = [
+            {
+                name: "🔄 Reset complet (supabase db reset) - Recommandé",
+                value: "reset",
+            },
+        ];
+        if (hasDownMigrations) {
+            choices.unshift({
+                name: "⬇️  Exécuter les migrations down du module",
+                value: "down",
+            });
+        }
+        choices.push({
+            name: "⏭️  Ignorer (garder les données en base)",
+            value: "skip",
+        });
+        const { migrationAction } = await inquirer.prompt([
+            {
+                type: "rawlist",
+                name: "migrationAction",
+                message: "Comment gérer les données du module en base ?",
+                choices,
+            },
+        ]);
+        if (migrationAction === "down" && hasDownMigrations) {
+            console.log(chalk.yellow("\n⬇️  Exécution des migrations down..."));
+            // Exécuter les fichiers .sql du dossier migrations-down dans l'ordre inverse
+            const downFiles = fs
+                .readdirSync(moduleMigrationsDownDir)
+                .filter((f) => f.endsWith(".sql"))
+                .sort()
+                .reverse();
+            for (const downFile of downFiles) {
+                const downFilePath = path.join(moduleMigrationsDownDir, downFile);
+                // Extraire le timestamp de la migration (14 premiers caractères)
+                const migrationVersion = downFile.split("_")[0]; // Prend la partie avant le premier underscore
+                try {
+                    console.log(chalk.gray(`  Exécution de ${downFile}...`));
+                    execSync(`psql "postgresql://postgres:postgres@127.0.0.1:54322/postgres" -f "${downFilePath}"`, {
+                        cwd: targetDir,
+                        stdio: "inherit",
+                    });
+                    // Supprimer l'entrée de supabase_migrations.schema_migrations
+                    try {
+                        const deleteQuery = `DELETE FROM supabase_migrations.schema_migrations WHERE version = '${migrationVersion}';`;
+                        const result = execSync(`psql "postgresql://postgres:postgres@127.0.0.1:54322/postgres" -c "${deleteQuery}"`, {
+                            cwd: targetDir,
+                            encoding: "utf-8",
+                        });
+                        console.log(chalk.gray(`  ✓ Supprimé ${migrationVersion} de schema_migrations (${result.trim()})`));
+                    }
+                    catch (error) {
+                        console.error(chalk.red(`  ❌ Erreur lors de la suppression de ${migrationVersion}: ${error.message}`));
+                    }
+                    console.log(chalk.green(`  ✓ ${downFile}`));
+                }
+                catch {
+                    console.error(chalk.red(`  ❌ Erreur avec ${downFile}`));
+                }
+            }
+        }
+        else if (migrationAction === "reset") {
+            console.log(chalk.yellow("\n🔄 Reset de la base de données..."));
+            // D'abord supprimer les fichiers de migration du projet
+            console.log(chalk.yellow("\n📋 Suppression des fichiers de migration..."));
+            for (const file of migrationFiles) {
+                const filePath = path.join(projectMigrationsDir, file);
+                if (fs.existsSync(filePath)) {
+                    await fs.remove(filePath);
+                    console.log(chalk.gray(`  ✓ Supprimé ${file}`));
+                }
+            }
+            try {
+                execSync("supabase db reset", { cwd: targetDir, stdio: "inherit" });
+                console.log(chalk.green("✓ Base de données réinitialisée"));
+            }
+            catch {
+                console.error(chalk.red("❌ Erreur lors du reset"));
+            }
+        }
+        else {
+            console.log(chalk.gray("\n⚠️  Données conservées en base. Nettoyez manuellement si nécessaire.\n"));
+        }
+        // Supprimer les fichiers de migration du projet (si pas déjà fait)
+        if (migrationAction !== "reset") {
+            console.log(chalk.yellow("\n📋 Suppression des fichiers de migration..."));
+            for (const file of migrationFiles) {
+                const filePath = path.join(projectMigrationsDir, file);
+                if (fs.existsSync(filePath)) {
+                    await fs.remove(filePath);
+                    console.log(chalk.gray(`  ✓ ${file}`));
+                }
+            }
+            // Supprimer les entrées de supabase_migrations.schema_migrations
+            if (migrationFiles.length > 0) {
+                console.log(chalk.yellow("\n🗄️  Nettoyage de schema_migrations..."));
+                // Extraire uniquement les timestamps (14 premiers caractères) de chaque fichier de migration
+                const versions = migrationFiles
+                    .map((f) => {
+                    const timestamp = f.split("_")[0]; // Prend la partie avant le premier underscore
+                    return `'${timestamp}'`;
+                })
+                    .join(", ");
+                const deleteQuery = `DELETE FROM supabase_migrations.schema_migrations WHERE version IN (${versions});`;
+                try {
+                    const result = execSync(`psql "postgresql://postgres:postgres@127.0.0.1:54322/postgres" -c "${deleteQuery}"`, {
+                        cwd: targetDir,
+                        encoding: "utf-8",
+                    });
+                    console.log(chalk.gray(`  ✓ Supprimé ${migrationFiles.length} entrées de schema_migrations`));
+                    console.log(chalk.gray(`  ${result.trim()}`));
+                }
+                catch (error) {
+                    console.error(chalk.red(`  ❌ Erreur: ${error.message}`));
+                }
+            }
+        }
+    }
+    // 5. Marquer le module comme inactif dans modules.json
+    const modulesJsonPath = path.join(targetDir, ".lastbrain", "modules.json");
+    if (fs.existsSync(modulesJsonPath)) {
+        try {
+            const modulesConfig = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
+            const moduleEntry = modulesConfig.modules.find((m) => m.package === module.package);
+            if (moduleEntry) {
+                moduleEntry.active = false;
+                moduleEntry.migrations = [];
+            }
+            fs.writeFileSync(modulesJsonPath, JSON.stringify(modulesConfig, null, 2));
+            console.log(chalk.gray("\n✓ Module marqué comme inactif dans modules.json"));
+        }
+        catch {
+            console.error(chalk.red("❌ Erreur lors de la mise à jour de modules.json"));
+        }
+    }
+    // 5.5. Note: On ne supprime PAS le module du registre central
+    // car cette commande est pour les utilisateurs finaux qui n'ont pas accès à core/config/modules.ts
+    // Pour supprimer un module du monorepo, utiliser: pnpm delete-module
+    // 6. Nettoyer les dépendances
+    console.log(chalk.yellow("\n🧹 Nettoyage des dépendances..."));
+    try {
+        execSync("pnpm install", { cwd: targetDir, stdio: "inherit" });
+    }
+    catch {
+        console.error(chalk.red("❌ Erreur lors du nettoyage"));
+        process.exit(1);
+    }
+    console.log(chalk.green(`\n✅ Module ${module.displayName} supprimé avec succès!\n`));
+    // 7. Rebuilder les modules pour mettre à jour les fichiers générés
+    console.log(chalk.yellow("🔧 Mise à jour des modules..."));
+    try {
+        execSync("pnpm run build:modules", { cwd: targetDir, stdio: "inherit" });
+        console.log(chalk.green("✓ Modules mis à jour"));
+    }
+    catch {
+        console.warn(chalk.yellow("⚠️  Erreur lors de la mise à jour des modules"));
+    }
+    console.log(chalk.gray("Le serveur de développement redémarrera automatiquement.\n"));
+}

package/dist/src/scripts/readme-build.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=readme-build.d.ts.map

package/dist/src/scripts/readme-build.d.ts.map

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

package/dist/src/scripts/readme-build.js

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { getModuleConfigs } from "../modules/module-loader.js";
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.join(scriptDir, "..", "..");
+const projectRoot = path.join(packageRoot, "..", "..");
+const webAppRoot = path.join(projectRoot, "apps/web");
+const outputPath = path.join(webAppRoot, "README.md");
+function resolveModuleReadme(moduleName) {
+    const fallbackPaths = [
+        path.join(projectRoot, "packages", moduleName.replace("@lastbrain/", ""), "README.md"),
+        path.join(projectRoot, "node_modules", ...moduleName.split("/"), "README.md"),
+    ];
+    for (const candidate of fallbackPaths) {
+        if (fs.existsSync(candidate)) {
+            return fs.readFileSync(candidate, "utf-8");
+        }
+    }
+    return null;
+}
+function buildGeneratedReadme() {
+    const baseReadmePath = path.join(projectRoot, "packages/app/README.md");
+    const baseReadme = fs.existsSync(baseReadmePath)
+        ? fs.readFileSync(baseReadmePath, "utf-8")
+        : "";
+    const modules = getModuleConfigs();
+    const moduleSections = modules
+        .map((module) => {
+        const readme = resolveModuleReadme(module.moduleName) ||
+            "Aucun README disponible pour ce module.";
+        return `## Module ${module.moduleName}\n\n${readme}\n`;
+    })
+        .join("\n");
+    const content = `# LastBrain App Docs\n\n${baseReadme}\n\n---\n\n## Modules\n\n${moduleSections}\n\n## Commandes clés\n\n- pnpm build:modules\n- pnpm db:migrations:sync\n- pnpm db:init\n- pnpm dev\n`;
+    fs.writeFileSync(outputPath, content);
+    console.log(`📝 Generated aggregated README: ${outputPath}`);
+}
+buildGeneratedReadme();

package/dist/src/scripts/script-runner.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Exécute un script via node en ajustant le chemin
+ */
+export declare function runScript(scriptName: string, args?: string[]): Promise<void>;
+//# sourceMappingURL=script-runner.d.ts.map

package/dist/src/scripts/script-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-runner.d.ts","sourceRoot":"","sources":["../../../src/scripts/script-runner.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAsB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,EAAO,iBAqBtE"}

package/dist/src/scripts/script-runner.js

@@ -0,0 +1,25 @@
+import { spawn } from "child_process";
+import path from "path";
+/**
+ * Exécute un script via node en ajustant le chemin
+ */
+export async function runScript(scriptName, args = []) {
+    return new Promise((resolve, reject) => {
+        const scriptPath = path.join(__dirname, `${scriptName}.js`);
+        const child = spawn("node", [scriptPath, ...args], {
+            stdio: "inherit",
+            env: { ...process.env, PROJECT_ROOT: process.cwd() },
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Script ${scriptName} exited with code ${code}`));
+            }
+        });
+        child.on("error", (error) => {
+            reject(error);
+        });
+    });
+}

package/dist/src/templates/AuthGuidePage.d.ts

@@ -0,0 +1,2 @@
+export declare function AuthGuidePage(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AuthGuidePage.d.ts.map

package/dist/src/templates/AuthGuidePage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthGuidePage.d.ts","sourceRoot":"","sources":["../../../src/templates/AuthGuidePage.tsx"],"names":[],"mappings":"AAIA,wBAAgB,aAAa,4CA+D5B"}

package/dist/src/templates/AuthGuidePage.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Card, Code, Divider, Chip } from "@lastbrain/ui";
+export function AuthGuidePage() {
+    return (_jsxs("div", { className: "max-w-5xl mx-auto px-6 py-10 space-y-10", children: [_jsxs("header", { className: "space-y-3", children: [_jsx("h1", { className: "text-3xl font-bold", children: "Guide Authentification" }), _jsx("p", { className: "text-slate-600 dark:text-slate-300 text-sm", children: "Pages publiques signin/signup/reset et endpoints API associ\u00E9s." }), _jsxs("div", { className: "flex gap-2 flex-wrap", children: [_jsx(Chip, { color: "primary", children: "Pages" }), _jsx(Chip, { color: "secondary", children: "API" }), _jsx(Chip, { color: "success", children: "Sessions" })] })] }), _jsx(Divider, {}), _jsxs(Card, { className: "p-6 space-y-3", children: [_jsx("h2", { className: "text-lg font-semibold", children: "Pages disponibles" }), _jsxs("ul", { className: "list-disc pl-5 text-sm space-y-1 text-slate-600 dark:text-slate-400", children: [_jsxs("li", { children: [_jsx("code", { children: "/signin" }), " : connexion"] }), _jsxs("li", { children: [_jsx("code", { children: "/signup" }), " : inscription"] }), _jsxs("li", { children: [_jsx("code", { children: "/reset-password" }), " (exemple)"] })] }), _jsx(Code, { className: "text-xs block", children: `import { SignInPage } from "@lastbrain/module-auth";` })] }), _jsxs(Card, { className: "p-6 space-y-3", children: [_jsx("h2", { className: "text-lg font-semibold", children: "API Route" }), _jsx(Code, { className: "text-xs block", children: "/api/auth/signin (POST)" }), _jsx(Code, { className: "text-xs block", children: `export { POST } from "@lastbrain/module-auth/api/public/signin";` })] }), _jsxs(Card, { className: "p-6 space-y-4", children: [_jsx("h2", { className: "text-lg font-semibold", children: "Personnalisation" }), _jsxs("ol", { className: "list-decimal pl-5 text-sm space-y-1 text-slate-600 dark:text-slate-400", children: [_jsx("li", { children: "Override wrapper route si besoin" }), _jsxs("li", { children: ["Modifier composant dans", " ", _jsx("code", { children: "packages/module-auth/src/web/public" })] }), _jsxs("li", { children: ["Recompiler module (", _jsx(Code, { className: "text-xs inline", children: "pnpm dev" }), ")"] }), _jsx("li", { children: "Hot reload c\u00F4t\u00E9 app" })] })] }), _jsxs(Card, { className: "p-6 space-y-2", children: [_jsx("h2", { className: "text-lg font-semibold", children: "Exemple d'int\u00E9gration" }), _jsx(Code, { className: "text-xs whitespace-pre-wrap", children: `import { SignInPage } from "@lastbrain/module-auth";
+
+export default function SignIn() {
+  return <SignInPage />
+}` })] }), _jsx("footer", { className: "text-center text-xs text-slate-500 dark:text-slate-500", children: "Pour ajouter un autre provider OAuth: \u00E9tendre module-auth ou cr\u00E9er module s\u00E9par\u00E9." })] }));
+}

package/dist/src/templates/DefaultDoc.d.ts

@@ -0,0 +1,2 @@
+export declare function DefaultDocumentation(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DefaultDoc.d.ts.map