@lastbrain/app 0.1.8 → 0.1.10

package/src/scripts/README.md

@@ -0,0 +1,262 @@
+# Scripts LastBrain
+
+Ce répertoire contient tous les scripts utilitaires pour gérer les applications et modules LastBrain.
+
+## Scripts disponibles
+
+### `init-app.ts`
+
+Initialise une nouvelle application Next.js LastBrain avec toute la structure nécessaire.
+
+**Usage :**
+
+```bash
+pnpm lastbrain init [directory] [options]
+```
+
+**Options :**
+
+- `--force` : Écrase les fichiers existants
+- `--heroui` : Utilise HeroUI au lieu de NextUI
+- `--with-auth` : Inclut le module d'authentification
+- `--no-interactive` : Mode non-interactif
+
+### `module-create.ts`
+
+Crée un nouveau module dans `packages/module-{nom}` avec toute la structure nécessaire.
+
+**Usage :**
+
+```bash
+pnpm lastbrain create-module
+```
+
+**Fonctionnalités :**
+
+- Génération interactive du module
+- Création des pages (public/auth/admin)
+- Création des routes API CRUD
+- Génération des migrations SQL
+- Configuration complète (package.json, tsconfig.json, build.config.ts)
+
+**Voir :** [MODULE_CREATION.md](../../../../docs/MODULE_CREATION.md)
+
+### `module-add.ts`
+
+Ajoute un module existant à l'application courante.
+
+**Usage :**
+
+```bash
+pnpm lastbrain add-module <nom-du-module>
+```
+
+**Exemple :**
+
+```bash
+pnpm lastbrain add-module auth
+```
+
+**Actions effectuées :**
+
+- Ajout de la dépendance au package.json
+- Installation via pnpm
+- Copie des migrations du module
+- Application des migrations (avec choix reset/push/skip)
+- Enregistrement dans `.lastbrain/modules.json`
+
+### `module-remove.ts`
+
+Supprime un module de l'application courante.
+
+**Usage :**
+
+```bash
+pnpm lastbrain remove-module <nom-du-module>
+```
+
+**Actions effectuées :**
+
+- Suppression de la dépendance du package.json
+- Suppression du module de `.lastbrain/modules.json`
+- Nettoyage via pnpm
+
+**Note :** Les migrations ne sont pas automatiquement inversées.
+
+### `module-list.ts`
+
+Liste tous les modules disponibles et ceux installés dans l'application courante.
+
+**Usage :**
+
+```bash
+pnpm lastbrain list-modules
+```
+
+**Affiche :**
+
+- ✅ Modules installés
+- 📦 Modules disponibles
+
+### `module-build.ts`
+
+Génère automatiquement les routes et pages de l'application à partir des modules installés.
+
+**Usage :**
+
+```bash
+pnpm build:modules
+```
+
+**Actions effectuées :**
+
+- Lecture des `build.config.ts` de tous les modules installés
+- Génération de `app/navigation.generated.ts`
+- Création des pages dans les sections appropriées (public/auth/admin)
+- Création des routes API
+
+**Note :** Utilisé par le script `dev:sync` en mode watch.
+
+### `db-init.ts`
+
+Initialise la base de données Supabase locale.
+
+**Usage :**
+
+```bash
+pnpm db:init
+```
+
+**Actions effectuées :**
+
+- Démarre Supabase local (si pas déjà démarré)
+- Génère le fichier `.env.local` avec les clés Supabase
+- Applique les migrations de base
+- Reset de la base de données
+
+### `db-migrations-sync.ts`
+
+Synchronise les migrations de tous les modules avec la base de données.
+
+**Usage :**
+
+```bash
+pnpm db:migrations:sync
+```
+
+**Actions effectuées :**
+
+- Collecte toutes les migrations des modules installés
+- Copie dans `supabase/migrations/`
+- Applique les migrations (via `supabase db push` ou `supabase db reset`)
+
+### `dev-sync.ts`
+
+Lance le mode développement avec synchronisation automatique des modules.
+
+**Usage :**
+
+```bash
+pnpm dev:sync
+```
+
+**Actions effectuées :**
+
+- Watch des changements dans les modules
+- Régénération automatique des routes
+- Synchronisation des migrations
+- Redémarrage automatique du serveur Next.js
+
+### `readme-build.ts`
+
+Génère la documentation README.md de l'application.
+
+**Usage :**
+
+```bash
+pnpm readme:create
+```
+
+**Actions effectuées :**
+
+- Analyse la structure de l'application
+- Collecte les informations des modules installés
+- Génère un README complet avec la documentation
+
+## Architecture des scripts
+
+### Dépendances communes
+
+Tous les scripts utilisent :
+
+- `fs-extra` : Gestion des fichiers
+- `chalk` : Affichage coloré dans le terminal
+- `inquirer` : Prompts interactifs (pour certains scripts)
+- `commander` : Parsing des arguments CLI
+
+### Structure type d'un script
+
+```typescript
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+
+export async function monScript(targetDir: string, options?: any) {
+  console.log(chalk.blue("\n🚀 Début du script...\n"));
+
+  try {
+    // Logique du script
+    console.log(chalk.green("✅ Succès!"));
+  } catch (error) {
+    console.error(chalk.red("❌ Erreur:"), error);
+    process.exit(1);
+  }
+}
+```
+
+## Ajouter un nouveau script
+
+1. Créer le fichier TypeScript dans `src/scripts/`
+2. Exporter une fonction principale
+3. Ajouter la commande dans `src/cli.ts`
+4. Ajouter éventuellement un script NPM dans `package.json`
+5. Documenter ici et dans les docs principales
+
+## Bonnes pratiques
+
+1. **Messages clairs** : Utilisez `chalk` pour des messages colorés et informatifs
+2. **Gestion d'erreurs** : Toujours catch les erreurs et donner un message explicite
+3. **Confirmations** : Pour les opérations destructives, demander confirmation
+4. **Idempotence** : Les scripts doivent pouvoir être exécutés plusieurs fois
+5. **Logs** : Logger les actions importantes pour faciliter le debug
+6. **Exit codes** : Utiliser `process.exit(1)` en cas d'erreur
+
+## Tests
+
+Pour tester un script :
+
+```bash
+# 1. Compiler le package
+pnpm build
+
+# 2. Exécuter la commande
+pnpm lastbrain <commande> [args]
+```
+
+## Contribution
+
+Pour contribuer un nouveau script :
+
+1. Fork le projet
+2. Créer une branche feature
+3. Implémenter le script avec tests
+4. Documenter dans ce README
+5. Créer une Pull Request
+
+## Support
+
+Pour toute question ou problème :
+
+- Ouvrir une issue sur GitHub
+- Consulter la documentation dans `/docs`
+- Rejoindre le Discord LastBrain

package/src/scripts/db-init.ts

@@ -0,0 +1,338 @@
+import { spawn, spawnSync, execSync, execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Utiliser PROJECT_ROOT si défini (pour pnpm --filter), sinon process.cwd()
+const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+const supabaseDir = path.join(projectRoot, "supabase");
+
+const envTargets = [path.join(projectRoot, ".env.local")];
+
+// Trouver le template dans le package @lastbrain/app
+const packageAppDir = path
+  .dirname(fileURLToPath(import.meta.url))
+  .replace(/dist\/scripts$/, "src");
+const envExampleTemplate = path.join(
+  packageAppDir,
+  "templates/env.example/.env.example"
+);
+
+function ensureDirectory(dir: string) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function runSupabase(...args: string[]): Buffer | null;
+function runSupabase(captureOutput: boolean, ...args: string[]): Buffer | null;
+function runSupabase(...args: any[]): Buffer | null {
+  const bin = path.join(projectRoot, "node_modules", ".bin", "supabase");
+
+  // Ensure PATH includes common binary locations
+  const PATH = process.env.PATH || "";
+  const enhancedPath = `/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:${PATH}`;
+
+  // Check if first argument is a boolean (captureOutput flag)
+  const captureOutput = typeof args[0] === "boolean" ? args.shift() : false;
+  const stdio = captureOutput ? "pipe" : "inherit";
+
+  const runners = [
+    () =>
+      spawnSync("supabase", args, {
+        cwd: projectRoot,
+        stdio: stdio as any,
+        env: { ...process.env, PATH: enhancedPath },
+        shell: true,
+      }),
+    () =>
+      spawnSync(bin, args, {
+        cwd: projectRoot,
+        stdio: stdio as any,
+        env: { ...process.env, PATH: enhancedPath },
+      }),
+    () =>
+      spawnSync("pnpm", ["exec", "supabase", ...args], {
+        cwd: projectRoot,
+        stdio: stdio as any,
+        env: { ...process.env, PATH: enhancedPath },
+        shell: true,
+      }),
+  ];
+
+  for (let i = 0; i < runners.length; i++) {
+    const result = runners[i]();
+
+    if (result.error) {
+      // Si c'est une erreur ENOENT (commande non trouvée), essayer la suivante
+      if ((result.error as any).code === "ENOENT") {
+        continue;
+      }
+      // Si c'est une autre erreur, la propager
+      throw result.error;
+    }
+
+    // Si le processus s'est terminé avec un code de sortie non nul, propager l'erreur
+    if (result.status !== 0) {
+      const error: any = new Error(
+        `Command failed with exit code ${result.status}`
+      );
+      error.status = result.status;
+      throw error;
+    }
+
+    // Succès !
+    return result.stdout || null;
+  }
+
+  throw new Error(
+    "Unable to locate Supabase CLI (install it globally or via pnpm)."
+  );
+}
+
+function ensureSupabaseInit() {
+  const configPath = path.join(supabaseDir, "config.toml");
+  if (!fs.existsSync(configPath)) {
+    runSupabase("init");
+  }
+}
+
+function parseEnvFile(filePath: string) {
+  const data = fs.readFileSync(filePath, "utf-8");
+  return Object.fromEntries(
+    data
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith("#"))
+      .map((line) => {
+        const [key, ...value] = line.split("=");
+        return [key, value.join("=")];
+      })
+  ) as Record<string, string>;
+}
+
+function ensureEnvFile(values: Record<string, string>) {
+  const content = Object.entries(values)
+    .map(([key, value]) => `${key}=${value}`)
+    .join("\n");
+
+  envTargets.forEach((target) => {
+    fs.writeFileSync(target, content);
+    console.log(`📝 Wrote env to ${target}`);
+  });
+}
+
+function buildEnvPayload(creds: Record<string, string | undefined>) {
+  return {
+    NEXT_PUBLIC_SUPABASE_URL: creds.url ?? "",
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: creds.anon ?? "",
+    SUPABASE_URL: creds.url ?? "",
+    SUPABASE_ANON_KEY: creds.anon ?? "",
+    SUPABASE_SERVICE_ROLE_KEY: creds.service ?? "",
+    SUPABASE_DB_URL: creds.db ?? "",
+    SUPABASE_JWT_SECRET: creds.jwt ?? "",
+  };
+}
+
+function applyEnvToProcess(values: Record<string, string>) {
+  process.env.NEXT_PUBLIC_SUPABASE_URL = values.NEXT_PUBLIC_SUPABASE_URL;
+  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY =
+    values.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+  process.env.SUPABASE_URL = values.SUPABASE_URL;
+  process.env.SUPABASE_ANON_KEY = values.SUPABASE_ANON_KEY;
+  process.env.SUPABASE_SERVICE_ROLE_KEY = values.SUPABASE_SERVICE_ROLE_KEY;
+  process.env.SUPABASE_DB_URL = values.SUPABASE_DB_URL;
+  process.env.SUPABASE_JWT_SECRET = values.SUPABASE_JWT_SECRET;
+}
+
+function copyEnvExample() {
+  if (!fs.existsSync(envExampleTemplate)) {
+    return null;
+  }
+  const target = envTargets[0];
+  ensureDirectory(path.dirname(target));
+  fs.copyFileSync(envExampleTemplate, target);
+  return target;
+}
+
+function readSupabaseEnv() {
+  const candidate = path.join(supabaseDir, ".env");
+  if (fs.existsSync(candidate)) {
+    return parseEnvFile(candidate);
+  }
+  const candidateLocal = path.join(supabaseDir, ".env.local");
+  if (fs.existsSync(candidateLocal)) {
+    return parseEnvFile(candidateLocal);
+  }
+  return {} as Record<string, string>;
+}
+
+function getSupabaseStatusEnv() {
+  try {
+    const result = runSupabase(true, "status", "-o", "env");
+    if (!result) return null;
+
+    const envString = result.toString();
+    const lines = envString
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith("#") && line.includes("="));
+
+    const env: Record<string, string> = {};
+    for (const line of lines) {
+      const equalIndex = line.indexOf("=");
+      if (equalIndex > 0) {
+        const key = line.substring(0, equalIndex);
+        const value = line
+          .substring(equalIndex + 1)
+          .replace(/^["']|["']$/g, "");
+        env[key] = value;
+      }
+    }
+
+    return Object.keys(env).length > 0 ? env : null;
+  } catch {
+    return null;
+  }
+}
+
+function buildCredsFromStatus(status: Record<string, any>) {
+  if (!status) {
+    return null;
+  }
+  return {
+    url: status.API_URL ?? status.SUPABASE_URL ?? "",
+    anon: status.ANON_KEY ?? "",
+    service: status.SERVICE_ROLE_KEY ?? status.SECRET_KEY ?? "",
+    jwt: status.JWT_SECRET ?? "",
+    db: status.DB_URL ?? status.DATABASE_URL ?? "",
+  };
+}
+
+function findLocalKeysFallback() {
+  const env = readSupabaseEnv();
+  if (Object.keys(env).length === 0) {
+    return null;
+  }
+
+  return {
+    url: env.SUPABASE_URL ?? env.API_URL ?? null,
+    anon: env.SUPABASE_ANON_KEY ?? env.ANON_KEY ?? null,
+    service: env.SUPABASE_SERVICE_ROLE_KEY ?? env.SERVICE_ROLE_KEY ?? null,
+    jwt: env.JWT_SECRET ?? null,
+    db: env.SUPABASE_DB_URL ?? env.DB_URL ?? null,
+  };
+}
+
+async function wait(ms: number) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForStatus() {
+  const maxAttempts = 10;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const status = getSupabaseStatusEnv();
+    if (status && Object.keys(status).length > 0) {
+      return status;
+    }
+    await wait(1000);
+  }
+  return null;
+}
+
+async function gatherCredentials() {
+  const envStatus = await waitForStatus();
+  let creds = envStatus ? buildCredsFromStatus(envStatus) : null;
+
+  if (!creds || !creds.url || !creds.anon) {
+    const fallback = findLocalKeysFallback();
+    if (fallback) {
+      creds = {
+        url: fallback.url ?? "",
+        anon: fallback.anon ?? "",
+        service: fallback.service ?? "",
+        jwt: fallback.jwt ?? "",
+        db: fallback.db ?? "",
+      };
+    }
+  }
+
+  return creds;
+}
+
+async function main() {
+  ensureSupabaseInit();
+
+  const PATH = process.env.PATH || "";
+  const enhancedPath = `/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:${PATH}`;
+
+  const migrationResult = spawnSync(
+    "pnpm",
+    ["--filter", "web", "db:migrations:sync"],
+    {
+      cwd: projectRoot,
+      stdio: "inherit",
+      env: { ...process.env, PATH: enhancedPath },
+      shell: true,
+    }
+  );
+
+  if (migrationResult.error || migrationResult.status !== 0) {
+    console.warn("⚠️ Migration sync failed, continuing anyway...");
+  }
+
+  console.log("⚙️ Starting Supabase...");
+  try {
+    runSupabase("start");
+  } catch (error) {
+    console.warn("⚠️ Supabase start had issues, continuing...");
+  }
+
+  console.log("🔄 Resetting database...");
+  try {
+    runSupabase("db", "reset");
+    console.log("✅ Database reset complete.");
+  } catch (error) {
+    console.error("⚠️ supabase db reset failed:", error);
+    throw error;
+  }
+
+  console.log("🛠 Waiting for services to restart...");
+  await wait(3000);
+
+  const creds = await gatherCredentials();
+  if (creds && creds.url && creds.anon) {
+    const payload = buildEnvPayload(creds);
+    ensureEnvFile(payload);
+    applyEnvToProcess(payload);
+    console.log("✅ Environment configured successfully!");
+  } else {
+    const example = copyEnvExample();
+    if (example) {
+      console.log("ℹ️  Copied .env.example into .env.local as fallback.");
+    }
+    console.warn(
+      "⚠️  Impossible de récupérer automatiquement les accès Supabase."
+    );
+  }
+
+  if (process.argv.includes("--with-dev")) {
+    console.log("🚀 Launching Next dev server...");
+    const devProcess = spawn("pnpm", ["--filter", "web", "dev"], {
+      cwd: projectRoot,
+      stdio: "inherit",
+    });
+    devProcess.on("exit", (code) => {
+      console.log("🧹 Stopping Supabase");
+      try {
+        runSupabase("stop");
+      } catch {
+        // Ignore errors when stopping
+      }
+      process.exit(code ?? 0);
+    });
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/scripts/db-migrations-sync.ts

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { getModuleConfigs } from "../modules/module-loader.js";
+import type { ModuleBuildConfig } from "@lastbrain/core";
+
+// Utiliser PROJECT_ROOT si défini (pour pnpm --filter), sinon process.cwd()
+const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+const migrationsDir = path.join(projectRoot, "supabase/migrations");
+
+function ensureDirectory(dir: string) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+enum CopyStrategy {
+  overwrite,
+  skip,
+}
+
+function getModulePackageDir(moduleName: string) {
+  return path.join(projectRoot, "node_modules", ...moduleName.split("/"));
+}
+
+interface ModuleMigrationEntry {
+  enabled: boolean;
+  priority?: number;
+  path?: string;
+}
+
+function copyMigration(
+  moduleConfig: ModuleBuildConfig,
+  migration: ModuleMigrationEntry,
+  file: string,
+  index: number
+) {
+  const moduleDir = getModulePackageDir(moduleConfig.moduleName);
+  const migrationsPath = migration.path ?? "supabase/migrations";
+  const sourceDir = path.join(moduleDir, migrationsPath);
+  const sourceFile = path.join(sourceDir, file);
+
+  if (!fs.existsSync(sourceFile)) {
+    console.warn(`⚠️ Missing migration file ${sourceFile}`);
+    return;
+  }
+
+  ensureDirectory(migrationsDir);
+  const moduleSlug = moduleConfig.moduleName.replace("@lastbrain/", "module-");
+  const prefix = String((migration.priority ?? 0) * 10 + index + 1).padStart(
+    3,
+    "0"
+  );
+  const fileName = `${prefix}_${moduleSlug}_${file}`;
+  const targetFile = path.join(migrationsDir, fileName);
+
+  fs.copyFileSync(sourceFile, targetFile);
+  console.log(`📜 Copied migration ${fileName}`);
+}
+
+function syncModuleMigrations() {
+  const moduleConfigs = getModuleConfigs();
+  moduleConfigs.forEach((moduleConfig) => {
+    const migrationBlock = moduleConfig.migrations;
+    if (!migrationBlock || !migrationBlock.enabled) {
+      return;
+    }
+
+    const moduleMigrationPath = path.join(
+      getModulePackageDir(moduleConfig.moduleName),
+      migrationBlock.path ?? "supabase/migrations"
+    );
+    let files = migrationBlock.files;
+    if (!files?.length && fs.existsSync(moduleMigrationPath)) {
+      files = fs
+        .readdirSync(moduleMigrationPath)
+        .filter((file) => file.endsWith(".sql"))
+        .sort();
+    }
+
+    files?.forEach((file, index) => {
+      copyMigration(moduleConfig, migrationBlock, file, index);
+    });
+  });
+}
+
+syncModuleMigrations();