@lastbrain/app 2.0.1 → 2.0.2

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

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

package/dist/src/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":"AAiCA,wBAAsB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,iBA+SpE"}

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

@@ -0,0 +1,232 @@
+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",
+    };
+}
+export async function addModule(moduleName, targetDir) {
+    console.log(chalk.blue(`\n🔧 Ajout 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 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 {
+        console.error(chalk.red("❌ Erreur lors de l'installation"));
+        process.exit(1);
+    }
+    // 3.1 Build du module ajouté (pour générer dist/ et éviter les erreurs d'import)
+    console.log(chalk.yellow(`\n🏗️  Build du module ${module.package}...`));
+    try {
+        // Trouver la racine du monorepo (chercher pnpm-workspace.yaml en remontant)
+        let workspaceRoot = targetDir;
+        let attempts = 0;
+        const maxAttempts = 6;
+        while (attempts < maxAttempts) {
+            if (fs.existsSync(path.join(workspaceRoot, "pnpm-workspace.yaml"))) {
+                break;
+            }
+            const parent = path.resolve(workspaceRoot, "..");
+            if (parent === workspaceRoot)
+                break;
+            workspaceRoot = parent;
+            attempts++;
+        }
+        if (!fs.existsSync(path.join(workspaceRoot, "pnpm-workspace.yaml"))) {
+            console.log(chalk.gray("  ℹ️  Impossible de localiser la racine du monorepo, build ignoré"));
+        }
+        else {
+            execSync(`pnpm --filter ${module.package} build`, {
+                cwd: workspaceRoot,
+                stdio: "inherit",
+            });
+            console.log(chalk.green("  ✓ Module compilé"));
+        }
+    }
+    catch {
+        console.log(chalk.yellow("  ⚠️  Build du module échoué, essayez: pnpm --filter"), module.package, "build");
+    }
+    // 5. Copier les migrations du module
+    const 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 {
+                    console.error(chalk.red("❌ Erreur lors du reset"));
+                }
+            }
+            else if (migrationAction === "push") {
+                console.log(chalk.yellow("\n⬆️  Application des nouvelles migrations..."));
+                // Appliquer directement avec psql au lieu de supabase migration up
+                const migrationsDir = path.join(targetDir, "supabase", "migrations");
+                const migrationFiles = fs
+                    .readdirSync(migrationsDir)
+                    .filter((f) => f.endsWith(".sql"))
+                    .filter((f) => copiedMigrationFiles.includes(f))
+                    .sort();
+                if (migrationFiles.length === 0) {
+                    console.log(chalk.yellow("⚠️  Aucune nouvelle migration à appliquer"));
+                }
+                else {
+                    try {
+                        const dbUrl = "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
+                        for (const file of migrationFiles) {
+                            const filePath = path.join(migrationsDir, file);
+                            console.log(chalk.gray(`   Exécution de ${file}...`));
+                            execSync(`psql "${dbUrl}" -f "${filePath}"`, {
+                                cwd: targetDir,
+                                stdio: "pipe",
+                            });
+                        }
+                        console.log(chalk.green(`✓ ${migrationFiles.length} migration(s) appliquée(s)`));
+                    }
+                    catch (_error) {
+                        console.error(chalk.red("❌ Erreur lors de l'application des migrations"));
+                        console.log(chalk.gray("\nVous pouvez essayer manuellement:\n  supabase db reset\n"));
+                    }
+                }
+            }
+            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`));
+    // 7. Générer automatiquement les routes du module
+    console.log(chalk.yellow("🔧 Génération des routes du module..."));
+    try {
+        execSync("pnpm run build:modules", { cwd: targetDir, stdio: "inherit" });
+        console.log(chalk.green("✓ Routes du module générées"));
+    }
+    catch {
+        console.error(chalk.red("❌ Erreur lors de la génération des routes"));
+        console.error(chalk.gray("Vous pouvez les générer manuellement avec: cd apps/<votre-app> && pnpm run build:modules"));
+    }
+    console.log(chalk.gray("\nLe serveur de développement redémarrera automatiquement.\n"));
+}

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

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

package/dist/src/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":"AAi6CA,wBAAsB,cAAc,kBA+FnC"}