@lastbrain/app 0.1.8 → 0.1.9

package/src/scripts/module-list.ts

@@ -0,0 +1,37 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import { AVAILABLE_MODULES } from "./module-add.js";
+
+export async function listModules(targetDir: string) {
+  console.log(chalk.blue("\n📦 Modules disponibles:\n"));
+
+  // Lire la config des modules installés
+  const modulesConfigPath = path.join(targetDir, ".lastbrain", "modules.json");
+  let installedModules: string[] = [];
+
+  if (fs.existsSync(modulesConfigPath)) {
+    const modulesConfig = await fs.readJson(modulesConfigPath);
+    installedModules = modulesConfig.modules || [];
+  }
+
+  // Afficher tous les modules disponibles
+  AVAILABLE_MODULES.forEach((module) => {
+    const isInstalled = installedModules.includes(module.package);
+    const status = isInstalled
+      ? chalk.green("✓ installé")
+      : chalk.gray("  disponible");
+
+    console.log(chalk.bold(`${module.displayName}`));
+    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}`);
+    console.log();
+  });
+
+  console.log(chalk.gray("Pour ajouter un module:"));
+  console.log(chalk.cyan("  pnpm lastbrain add-module <nom>\n"));
+  console.log(chalk.gray("Pour supprimer un module:"));
+  console.log(chalk.cyan("  pnpm lastbrain remove-module <nom>\n"));
+}

package/src/scripts/module-remove.ts

@@ -0,0 +1,367 @@
+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 "./module-add.js";
+
+async function removeGeneratedFiles(
+  moduleName: string,
+  modulePackage: string,
+  targetDir: string
+) {
+  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: string) {
+    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 (error) {
+          // 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: string, targetDir: string) {
+  console.log(chalk.blue(`\n🗑️  Suppression 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 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: string) => 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: string[] = [];
+    
+    if (fs.existsSync(modulesConfigPath)) {
+      const modulesConfig = await fs.readJson(modulesConfigPath);
+      const moduleEntry = modulesConfig.modules.find((m: any) => 
+        (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: any) {
+            console.error(chalk.red(`  ❌ Erreur lors de la suppression de ${migrationVersion}: ${error.message}`));
+          }
+          
+          console.log(chalk.green(`  ✓ ${downFile}`));
+        } catch (error) {
+          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 (error) {
+        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: any) {
+          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: any) => 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 (error) {
+      console.error(chalk.red("❌ Erreur lors de la mise à jour de modules.json"));
+    }
+  }
+
+  // 6. Nettoyer les dépendances
+  console.log(chalk.yellow("\n🧹 Nettoyage des dépendances..."));
+  try {
+    execSync("pnpm install", { cwd: targetDir, stdio: "inherit" });
+  } catch (error) {
+    console.error(chalk.red("❌ Erreur lors du nettoyage"));
+    process.exit(1);
+  }
+
+  console.log(
+    chalk.green(`\n✅ Module ${module.displayName} supprimé avec succès!\n`)
+  );
+  console.log(
+    chalk.gray("Le serveur de développement redémarrera automatiquement.\n")
+  );
+}

package/src/scripts/readme-build.ts

@@ -0,0 +1,60 @@
+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: string) {
+  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/src/styles.css

@@ -0,0 +1,3 @@
+@import "tailwindcss";
+
+/* Styles pour les composants @lastbrain/app */

package/src/templates/AuthGuidePage.tsx

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