@lastbrain/app 0.1.34 → 0.1.37

package/src/scripts/module-delete.ts

@@ -0,0 +1,202 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { fileURLToPath } from "url";
+import {
+  AVAILABLE_MODULES,
+  type ModuleMetadata,
+} 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: "list",
+      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: any) =>
+        `Ê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
+  const moduleDir = path.join(
+    rootDir,
+    "packages",
+    moduleMeta.package.replace("@lastbrain/", ""),
+  );
+  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: string[] = [];
+          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/src/scripts/module-list.ts

@@ -1,7 +1,10 @@
 import fs from "fs-extra";
 import path from "path";
 import chalk from "chalk";
-import { AVAILABLE_MODULES } from "./module-add.js";
+import {
+  AVAILABLE_MODULES,
+  type ModuleMetadata,
+} from "@lastbrain/core/config/modules";
 
 export async function listModules(targetDir: string) {
   console.log(chalk.blue("\n📦 Modules disponibles:\n"));
@@ -22,7 +25,11 @@ export async function listModules(targetDir: string) {
       ? chalk.green("✓ installé")
       : chalk.gray("  disponible");
 
-    console.log(chalk.bold(`${module.displayName}`));
+    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}`));

package/src/scripts/module-remove.ts

@@ -3,7 +3,33 @@ import path from "path";
 import chalk from "chalk";
 import { execSync } from "child_process";
 import inquirer from "inquirer";
-import { AVAILABLE_MODULES } from "./module-add.js";
+import {
+  AVAILABLE_MODULES,
+  type ModuleMetadata,
+} from "@lastbrain/core/config/modules";
+
+interface ModuleDefinition {
+  name: string;
+  package: string;
+  displayName: string;
+  description: string;
+  hasMigrations: boolean;
+  migrationsPath?: string;
+  migrationsDownPath?: string;
+}
+
+// Convert core module metadata to local module definition
+function toModuleDefinition(meta: ModuleMetadata): ModuleDefinition {
+  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: string,
@@ -68,17 +94,19 @@ async function removeGeneratedFiles(
 export async function removeModule(moduleName: string, targetDir: string) {
   console.log(chalk.blue(`\n🗑️  Suppression du module: ${moduleName}\n`));
 
-  const module = AVAILABLE_MODULES.find((m) => m.name === moduleName);
-  if (!module) {
+  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.name}: ${m.description}`));
+      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)) {
@@ -398,6 +426,10 @@ export async function removeModule(moduleName: string, targetDir: string) {
     }
   }
 
+  // 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 {