@seip/blue-bird 1.1.0 → 1.1.2

package/core/cli/docker.js

@@ -26,11 +26,14 @@ function getEnvVars() {
 }
 
 /**
- * Determines the target database type (mysql or postgres) from environment variables.
+ * Determines the target database type (sqlite, mysql, or postgres) from environment variables.
  * @param {Object} [env] - Environment dictionary.
- * @returns {string} 'postgres' or 'mysql'.
+ * @returns {string} 'sqlite', 'postgres', 'mysql', or 'none'.
  */
 function getDbType(env = getEnvVars()) {
+  if (env.DB_TYPE && (env.DB_TYPE.toLowerCase() === "sqlite" || env.DB_TYPE.toLowerCase() === "sqlite3")) {
+    return "sqlite";
+  }
   if (env.DB_TYPE && (env.DB_TYPE.toLowerCase() === "postgres" || env.DB_TYPE.toLowerCase() === "postgresql" || env.DB_TYPE.toLowerCase() === "pg")) {
     return "postgres";
   }
@@ -41,6 +44,9 @@ function getDbType(env = getEnvVars()) {
     return "none";
   }
   if (env.DATABASE_URL && !env.DATABASE_URL.startsWith("#")) {
+    if (env.DATABASE_URL.startsWith("sqlite://") || env.DATABASE_URL.startsWith("sqlite:")) {
+      return "sqlite";
+    }
     if (env.DATABASE_URL.startsWith("postgres://") || env.DATABASE_URL.startsWith("postgresql://")) {
       return "postgres";
     }
@@ -48,7 +54,7 @@ function getDbType(env = getEnvVars()) {
       return "mysql";
     }
   }
-  return "mysql";
+  return "sqlite";
 }
 
 /**
@@ -84,12 +90,23 @@ async function startCommand(service) {
   checkComposeFile();
   const dbType = getDbType();
 
-  if (service === "mysql" || service === "--mysql" || service === "postgres" || service === "--postgres" || service === "db" || service === "--db" || service === "dev") {
-    const targetContainer = (service === "postgres" || service === "--postgres") ? "postgres" : ((service === "mysql" || service === "--mysql") ? "mysql" : dbType);
+  if (service === "sqlite" || service === "--sqlite" || service === "mysql" || service === "--mysql" || service === "postgres" || service === "--postgres" || service === "db" || service === "--db" || service === "dev") {
+    const targetContainer = (service === "sqlite" || service === "--sqlite") ? "sqlite" : ((service === "postgres" || service === "--postgres") ? "postgres" : ((service === "mysql" || service === "--mysql") ? "mysql" : dbType));
     if (targetContainer === "none") {
       console.log(chalk.yellow("[INFO] DB_TYPE is set to 'none', skipping database container startup."));
       return;
     }
+    if (targetContainer === "sqlite") {
+      console.log(chalk.cyan("[INFO] SQLite is file-based (embedded in app). Starting Redis container..."));
+      const code = await runCmd("docker", ["compose", "up", "-d", "redis"]);
+      if (code === 0) {
+        console.log(chalk.green("Redis started."));
+      } else {
+        console.error(chalk.red("Error starting Redis."));
+        process.exit(1);
+      }
+      return;
+    }
     console.log(chalk.cyan(`Starting ${targetContainer.toUpperCase()} container...`));
     const code = await runCmd("docker", ["compose", "up", "-d", targetContainer]);
     if (code === 0) {
@@ -108,8 +125,8 @@ async function startCommand(service) {
       process.exit(1);
     }
   } else if (service === "dbs" || service === "databases") {
-    if (dbType === "none") {
-      console.log(chalk.cyan("DB_TYPE is 'none', starting Redis container only..."));
+    if (dbType === "none" || dbType === "sqlite") {
+      console.log(chalk.cyan(`DB_TYPE is '${dbType}' (embedded/none), starting Redis container only...`));
       const code = await runCmd("docker", ["compose", "up", "-d", "redis"]);
       if (code === 0) {
         console.log(chalk.green("Redis started."));
@@ -137,7 +154,7 @@ async function startCommand(service) {
       process.exit(1);
     }
   } else {
-    console.error(chalk.red(`Unknown service '${service}'. Use: mysql, postgres, db, redis, dbs, prod.`));
+    console.error(chalk.red(`Unknown service '${service}'. Use: sqlite, mysql, postgres, db, redis, dbs, prod.`));
     process.exit(1);
   }
 }
@@ -151,14 +168,16 @@ async function devCommand() {
   console.log(chalk.cyan("Starting development environment (Database + Redis)..."));
 
   const containers = ["redis"];
-  if (dbType !== "none") {
+  if (dbType !== "none" && dbType !== "sqlite") {
     containers.unshift(dbType);
   }
 
   const code = await runCmd("docker", ["compose", "up", "-d", ...containers]);
   if (code === 0) {
     console.log(chalk.green("Development containers started."));
-    console.log(chalk.cyan("View live logs with: npx blue-bird docker logs db"));
+    if (dbType !== "none" && dbType !== "sqlite") {
+      console.log(chalk.cyan("View live logs with: npx blue-bird docker logs db"));
+    }
     console.log(chalk.yellow("Now execute: npm run dev"));
   } else {
     console.error(chalk.red("Error starting development environment."));
@@ -178,10 +197,10 @@ async function stopCommand(service) {
     console.log(chalk.cyan("Stopping all Blue Bird containers..."));
     await runCmd("docker", ["compose", "--profile", "prod", "down"]);
     console.log(chalk.green("All containers stopped."));
-  } else if (service === "mysql" || service === "--mysql" || service === "postgres" || service === "--postgres" || service === "db" || service === "--db") {
-    const targetContainer = (service === "postgres" || service === "--postgres") ? "postgres" : ((service === "mysql" || service === "--mysql") ? "mysql" : dbType);
-    if (targetContainer === "none") {
-      console.log(chalk.yellow("[INFO] DB_TYPE is set to 'none', no database container to stop."));
+  } else if (service === "sqlite" || service === "--sqlite" || service === "mysql" || service === "--mysql" || service === "postgres" || service === "--postgres" || service === "db" || service === "--db") {
+    const targetContainer = (service === "sqlite" || service === "--sqlite") ? "sqlite" : ((service === "postgres" || service === "--postgres") ? "postgres" : ((service === "mysql" || service === "--mysql") ? "mysql" : dbType));
+    if (targetContainer === "none" || targetContainer === "sqlite") {
+      console.log(chalk.yellow(`[INFO] DB_TYPE is set to '${targetContainer}', no database container to stop.`));
       return;
     }
     console.log(chalk.cyan(`Stopping ${targetContainer.toUpperCase()}...`));
@@ -199,7 +218,7 @@ async function stopCommand(service) {
     await runCmd("docker", ["compose", "--profile", "prod", "rm", "-f", "app"]);
     console.log(chalk.green("App container stopped."));
   } else {
-    console.error(chalk.red(`Unknown service '${service}'. Use: all, mysql, postgres, db, redis, app.`));
+    console.error(chalk.red(`Unknown service '${service}'. Use: all, sqlite, mysql, postgres, db, redis, app.`));
     process.exit(1);
   }
 }
@@ -245,13 +264,17 @@ async function logsCommand(service, followOpt) {
   const follow = followOpt !== "--no-follow";
   const dbType = getDbType();
   let targetService = "app";
-  if (service === "mysql" || service === "postgres" || service === "db") {
+  if (service === "mysql" || service === "postgres" || service === "sqlite" || service === "db") {
     targetService = service === "db" ? dbType : service;
   }
   if (targetService === "none") {
     console.log(chalk.yellow("[INFO] DB_TYPE is set to 'none', no database container logs to display."));
     return;
   }
+  if (targetService === "sqlite") {
+    console.log(chalk.yellow("[INFO] SQLite is embedded in the Node.js application container. Displaying app logs:"));
+    targetService = "app";
+  }
 
   const cmdArgs = ["compose"];
   if (targetService === "app") {
@@ -267,22 +290,14 @@ async function logsCommand(service, followOpt) {
 }
 
 /**
- * Handles interactive shell connections into the MySQL or PostgreSQL container.
- * @param {string} userOpt - DB username.
- * @param {string} passOpt - DB password.
- * @param {string} dbOpt - DB database name.
- * @param {boolean} rootOpt - Flag for overriding database credentials to connect as root/postgres.
- * @param {string} explicitService - Explicit target service if specified ('mysql' or 'postgres').
- */
-/**
- * Handles interactive shell connections or smart queries into the MySQL or PostgreSQL container.
+ * Handles interactive shell connections or smart queries into the SQLite, MySQL, or PostgreSQL database.
  * @param {string[]} clientArgs - CLI arguments.
- * @param {string} explicitService - Explicit target service if specified ('mysql', 'postgres', 'psql', 'db').
+ * @param {string} explicitService - Explicit target service if specified ('sqlite', 'mysql', 'postgres', 'psql', 'db').
  */
 async function dbClientCommand(clientArgs = [], explicitService) {
   checkComposeFile();
   const env = getEnvVars();
-  const dbType = explicitService === "postgres" || explicitService === "psql" ? "postgres" : (explicitService === "mysql" ? "mysql" : getDbType(env));
+  const dbType = explicitService === "sqlite" ? "sqlite" : (explicitService === "postgres" || explicitService === "psql" ? "postgres" : (explicitService === "mysql" ? "mysql" : getDbType(env)));
   if (dbType === "none") {
     console.error(chalk.yellow("[INFO] DB_TYPE is set to 'none'. No database container available to connect to."));
     return;
@@ -340,23 +355,27 @@ async function dbClientCommand(clientArgs = [], explicitService) {
     if (firstPos === "tables") {
       if (dbType === "postgres") {
         sqlQuery = "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';";
+      } else if (dbType === "sqlite") {
+        sqlQuery = "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';";
       } else {
         sqlQuery = "SHOW TABLES;";
       }
     } else if (firstPos === "columns" || firstPos === "cols" || firstPos === "describe" || firstPos === "desc") {
       const tableName = positionalArgs[1];
       if (!tableName) {
-        console.error(chalk.red("Error: Please specify a table name. Example: npx blue-bird docker mysql columns users"));
+        console.error(chalk.red("Error: Please specify a table name. Example: npx blue-bird docker db columns users"));
         process.exit(1);
       }
       if (dbType === "postgres") {
         sqlQuery = `SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = '${tableName}';`;
+      } else if (dbType === "sqlite") {
+        sqlQuery = `PRAGMA table_info(${tableName});`;
       } else {
         sqlQuery = `SHOW COLUMNS FROM ${tableName};`;
       }
     } else {
       const rawInput = positionalArgs.join(" ").trim();
-      const isFullQuery = /^(select|show|desc|describe|explain|insert|update|delete|create|drop|alter|truncate)\b/i.test(rawInput) || rawInput.includes(" ");
+      const isFullQuery = /^(select|show|desc|describe|explain|insert|update|delete|create|drop|alter|truncate|pragma)\b/i.test(rawInput) || rawInput.includes(" ");
       if (isFullQuery) {
         sqlQuery = rawInput;
       } else {
@@ -375,7 +394,53 @@ async function dbClientCommand(clientArgs = [], explicitService) {
     }
   }
 
-  if (dbType === "postgres") {
+  if (dbType === "sqlite") {
+    const dbFile = env.DB_FILE || "database/blue_bird.db";
+    const dbPath = path.isAbsolute(dbFile) ? dbFile : path.resolve(process.cwd(), dbFile);
+    if (!fs.existsSync(dbPath)) {
+      console.log(chalk.yellow(`[INFO] SQLite database file not found at '${dbFile}'. It will be created upon query execution.`));
+    }
+
+    try {
+      let BetterSqlite;
+      try {
+        BetterSqlite = (await import("better-sqlite3")).default;
+      } catch (err) {
+        console.error(chalk.red("Error: 'better-sqlite3' is not installed. Run: npm install better-sqlite3"));
+        process.exit(1);
+      }
+
+      const dir = path.dirname(dbPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      const db = new BetterSqlite(dbPath);
+      if (sqlQuery) {
+        console.log(chalk.cyan(`🔍 Executing SQLite query on '${dbFile}':`));
+        console.log(chalk.gray(`   ${sqlQuery}\n`));
+        const isSelect = /^(select|pragma|explain)/i.test(sqlQuery.trim());
+        if (isSelect) {
+          const rows = db.prepare(sqlQuery).all();
+          console.table(rows);
+        } else {
+          const info = db.prepare(sqlQuery).run();
+          console.log(chalk.green(`✔ Query executed successfully. Changes: ${info.changes}, LastInsertRowId: ${info.lastInsertRowid}`));
+        }
+      } else {
+        console.log(chalk.cyan(`Connected to SQLite database '${dbFile}'.`));
+        console.log(chalk.gray("Active Tables:"));
+        const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+        console.table(tables);
+        console.log(chalk.yellow("\nTip: Run queries with: npx blue-bird docker db \"SELECT * FROM table_name\""));
+      }
+      db.close();
+      return;
+    } catch (err) {
+      console.error(chalk.red("[DATABASE ERROR] SQLite operation failed:"), err.message);
+      process.exit(1);
+    }
+  } else if (dbType === "postgres") {
     dbUser = rootOpt ? "postgres" : (dbUser || env.DB_USER || "postgres");
     dbName = dbName || env.DB_NAME || "blue_bird";
 
@@ -434,8 +499,8 @@ async function dbClientCommand(clientArgs = [], explicitService) {
 }
 
 /**
- * Exports database schema & data into a .sql file inside backups/ folder.
- * @param {string} dbType - Target db type ('mysql', 'postgres', 'none').
+ * Exports database schema & data into a .sql or .db file inside backups/ folder.
+ * @param {string} dbType - Target db type ('sqlite', 'mysql', 'postgres', 'none').
  * @param {string} [filenameArg] - Custom backup filename.
  * @param {string} [userOpt] - Custom db user.
  * @param {string} [passOpt] - Custom db password.
@@ -456,6 +521,29 @@ async function exportDbCommand(dbType, filenameArg, userOpt, passOpt, dbOpt) {
     fs.mkdirSync(backupsDir, { recursive: true });
   }
 
+  if (targetDbType === "sqlite") {
+    const dbFile = env.DB_FILE || "database/blue_bird.db";
+    const srcDbPath = path.isAbsolute(dbFile) ? dbFile : path.resolve(process.cwd(), dbFile);
+    if (!fs.existsSync(srcDbPath)) {
+      console.error(chalk.red(`Error: SQLite database file '${dbFile}' does not exist.`));
+      return;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
+    const backupName = filenameArg || `backup_sqlite_${timestamp}.db`;
+    const destFile = path.isAbsolute(backupName)
+      ? backupName
+      : (backupName.includes("/") || backupName.includes("\\")
+        ? path.resolve(process.cwd(), backupName)
+        : path.join(backupsDir, backupName));
+
+    fs.copyFileSync(srcDbPath, destFile);
+    const stats = fs.statSync(destFile);
+    const sizeKb = (stats.size / 1024).toFixed(2);
+    console.log(chalk.green(`\n✔ SQLite database exported successfully!`));
+    console.log(chalk.cyan(`   File: ${path.relative(process.cwd(), destFile)} (${sizeKb} KB)`));
+    return;
+  }
+
   let outputFile;
   if (filenameArg) {
     let name = filenameArg;
@@ -525,8 +613,8 @@ function exportDbToFile(cmdArgs, outputFile) {
 }
 
 /**
- * Imports a .sql file from backups/ folder into the container database.
- * @param {string} dbType - Target db type ('mysql', 'postgres', 'none').
+ * Imports a .sql or .db file from backups/ folder into the database.
+ * @param {string} dbType - Target db type ('sqlite', 'mysql', 'postgres', 'none').
  * @param {string} [filenameArg] - Custom backup filename.
  * @param {string} [userOpt] - Custom db user.
  * @param {string} [passOpt] - Custom db password.
@@ -550,24 +638,29 @@ async function importDbCommand(dbType, filenameArg, userOpt, passOpt, dbOpt) {
   let inputFile;
   if (filenameArg) {
     let name = filenameArg;
-    if (!name.endsWith(".sql") && !fs.existsSync(name)) name += ".sql";
-    if (fs.existsSync(name)) {
+    if (path.isAbsolute(name) && fs.existsSync(name)) {
+      inputFile = name;
+    } else if (fs.existsSync(path.resolve(process.cwd(), name))) {
       inputFile = path.resolve(process.cwd(), name);
     } else if (fs.existsSync(path.join(backupsDir, name))) {
       inputFile = path.join(backupsDir, name);
+    } else if (fs.existsSync(path.join(backupsDir, `${name}.sql`))) {
+      inputFile = path.join(backupsDir, `${name}.sql`);
+    } else if (fs.existsSync(path.join(backupsDir, `${name}.db`))) {
+      inputFile = path.join(backupsDir, `${name}.db`);
     } else {
       console.error(chalk.red(`Error: Backup file '${filenameArg}' not found in current directory or 'backups/' folder.`));
       process.exit(1);
     }
   } else {
     const files = fs.readdirSync(backupsDir)
-      .filter(f => f.endsWith(".sql"))
+      .filter(f => f.endsWith(".sql") || f.endsWith(".db"))
       .map(f => ({ name: f, time: fs.statSync(path.join(backupsDir, f)).mtimeMs }))
       .sort((a, b) => b.time - a.time);
 
     if (files.length === 0) {
-      console.error(chalk.red(`Error: No .sql backup files found in 'backups/' directory.`));
-      console.log(chalk.yellow(`Usage: npx blue-bird docker import <file.sql>`));
+      console.error(chalk.red(`Error: No backup files found in 'backups/' directory.`));
+      console.log(chalk.yellow(`Usage: npx blue-bird docker import <file.sql | file.db>`));
       process.exit(1);
     }
 
@@ -575,6 +668,36 @@ async function importDbCommand(dbType, filenameArg, userOpt, passOpt, dbOpt) {
     console.log(chalk.yellow(`[INFO] No file specified. Using most recent backup: '${files[0].name}'`));
   }
 
+  const relPath = path.relative(process.cwd(), inputFile);
+
+  if (targetDbType === "sqlite") {
+    const dbFile = env.DB_FILE || "database/blue_bird.db";
+    const destDbPath = path.isAbsolute(dbFile) ? dbFile : path.resolve(process.cwd(), dbFile);
+    const destDir = path.dirname(destDbPath);
+    if (!fs.existsSync(destDir)) {
+      fs.mkdirSync(destDir, { recursive: true });
+    }
+
+    if (inputFile.endsWith(".db") || inputFile.endsWith(".sqlite")) {
+      fs.copyFileSync(inputFile, destDbPath);
+      console.log(chalk.green(`\n✔ SQLite database restored successfully from '${relPath}' to '${dbFile}'!`));
+      return;
+    }
+
+    try {
+      const BetterSqlite = (await import("better-sqlite3")).default;
+      const db = new BetterSqlite(destDbPath);
+      const sqlContent = fs.readFileSync(inputFile, "utf-8");
+      db.exec(sqlContent);
+      db.close();
+      console.log(chalk.green(`\n✔ SQL statements from '${relPath}' imported successfully into '${dbFile}'!`));
+    } catch (err) {
+      console.error(chalk.red(`\n✖ SQLite import failed:`), err.message);
+      process.exit(1);
+    }
+    return;
+  }
+
   const dbUser = userOpt || env.DB_USER || (targetDbType === "postgres" ? "postgres" : "root");
   const dbPass = passOpt || env.DB_PASSWORD || (targetDbType === "postgres" ? "postgres" : "root");
   const dbName = dbOpt || env.DB_NAME || "blue_bird";
@@ -586,7 +709,6 @@ async function importDbCommand(dbType, filenameArg, userOpt, passOpt, dbOpt) {
     cmdArgs = ["compose", "exec", "-T", "mysql", "mysql", `-u${dbUser}`, `-p${dbPass}`, dbName];
   }
 
-  const relPath = path.relative(process.cwd(), inputFile);
   console.log(chalk.cyan(`📥 Importing SQL dump '${relPath}' into ${targetDbType.toUpperCase()} database '${dbName}'...`));
 
   const success = await importDbFromFile(cmdArgs, inputFile);
@@ -733,7 +855,9 @@ async function main() {
   process.env.BLUEBIRD_PROJECT_NAME = projectName;
   process.env.TITLE = projectName;
 
-  const args = process.argv.slice(3);
+  const rawArgs = process.argv.slice(2);
+  const dockerIdx = rawArgs.indexOf("docker");
+  const args = dockerIdx !== -1 ? rawArgs.slice(dockerIdx + 1) : rawArgs;
   const command = args[0];
 
   if (!command) {
@@ -741,6 +865,7 @@ async function main() {
     return;
   }
 
+
   switch (command) {
     case "start":
       await startCommand(args[1]);
@@ -775,6 +900,7 @@ async function main() {
     case "redis":
       await redisCommand(args.slice(1));
       break;
+    case "sqlite":
     case "mysql":
     case "postgres":
     case "psql":
@@ -793,10 +919,61 @@ async function main() {
       await pruneCommand(force, all);
       break;
     }
+    case "help":
+    case "--help":
+    case "-h":
+      helpCommand();
+      break;
     default:
       console.log(chalk.yellow(`Unknown docker command: ${command}`));
-      console.log("Available commands: dev, start, stop, build, ps, logs, pm2, export/dump, import/restore, mysql/postgres/db, redis, df/disk, prune/clean");
+      console.log("Run 'npx blue-bird docker help' to see all available commands.");
   }
+
+}
+
+/**
+ * Displays the Blue Bird Docker CLI help manual.
+ */
+function helpCommand() {
+  console.log(chalk.bold.blue("\n🐦 Blue Bird Docker CLI — Command Reference"));
+  console.log(chalk.gray("────────────────────────────────────────────────────────────"));
+  console.log(chalk.bold("Usage: ") + chalk.cyan("npx blue-bird docker <command> [options]\n"));
+
+  console.log(chalk.bold.yellow("📦 Container Lifecycle:"));
+  console.log(`  ${chalk.green("dev")}                      Starts development containers (Redis / DB). Run npm run dev locally.`);
+  console.log(`  ${chalk.green("start [service]")}          Starts production stack (app, nginx, redis, db) or specific service.`);
+  console.log(`  ${chalk.green("start dev")}              Starts development services only.`);
+  console.log(`  ${chalk.green("start db")}               Starts configured database container only.`);
+  console.log(`  ${chalk.green("start redis")}            Starts Redis container only.`);
+  console.log(`  ${chalk.green("start dbs")}              Starts all database containers (DB + Redis).`);
+  console.log(`  ${chalk.green("stop [service]")}           Stops all running containers (or specific service).`);
+  console.log(`  ${chalk.green("build [--no-cache]")}      Builds or updates the Node.js production image.`);
+  console.log(`  ${chalk.green("ps | status")}             Lists status of active project containers.`);
+  console.log(`  ${chalk.green("logs [service] [-f]")}     Tails logs for container (app, db, redis, nginx).`);
+
+  console.log(chalk.bold.yellow("\n🗄️  Database & Inspection:"));
+  console.log(`  ${chalk.green("db | sqlite | mysql | psql")} [query/table]`);
+  console.log(`                             Inspects active database (tables, columns, or runs SQL query).`);
+  console.log(`                             ${chalk.gray("e.g. npx blue-bird docker db tables")}`);
+  console.log(`                             ${chalk.gray("e.g. npx blue-bird docker db columns users")}`);
+  console.log(`                             ${chalk.gray("e.g. npx blue-bird docker db \"SELECT * FROM users\"")}`);
+  console.log(`  ${chalk.green("export | dump [file]")}     Dumps database backup (.db file for SQLite or .sql) into backups/.`);
+  console.log(`  ${chalk.green("import | restore [file]")}   Restores database from backups/ (.db or .sql).`);
+
+  console.log(chalk.bold.yellow("\n⚡ Redis & Monitoring:"));
+  console.log(`  ${chalk.green("redis")} [command]          Runs interactive Redis CLI or smart subcommands.`);
+  console.log(`                             ${chalk.gray("e.g. npx blue-bird docker redis monitor")}`);
+  console.log(`                             ${chalk.gray("e.g. npx blue-bird docker redis keys")}`);
+  console.log(`                             ${chalk.gray("e.g. npx blue-bird docker redis key <keyname>")}`);
+  console.log(`  ${chalk.green("pm2 [args]")}               Runs PM2 commands inside app container (status, monit, reload).`);
+  console.log(`  ${chalk.green("df | disk")}                Shows Docker disk usage statistics.`);
+  console.log(`  ${chalk.green("prune | clean [-f] [-a]")}  Cleans unused volumes, dangling images, and build caches.`);
+
+  console.log(chalk.bold.yellow("\nℹ️  Help:"));
+  console.log(`  ${chalk.green("help | --help | -h")}       Displays this help message.`);
+  console.log(chalk.gray("────────────────────────────────────────────────────────────\n"));
 }
 
 main();
+
+

package/core/cli/init.js

@@ -28,8 +28,9 @@ class ProjectInit {
     let title = "Blue-Bird";
     let port = 3000;
     let appUrl = "http://localhost:3000";
-    let dbType = "none";
+    let dbType = "sqlite";
     let dbName = "blue_bird";
+    let dbFile = "database/blue_bird.db";
     let dbUser = "root";
     let dbPassword = "root";
     let dbPort = 3306;
@@ -55,11 +56,17 @@ class ProjectInit {
       appUrl = await ask("Application URL", defaultAppUrl);
 
       const dbTypeAns = await ask(
-        "Which database do you want to configure? (none / mysql / postgres)",
-        "none",
+        "Which database do you want to configure? (sqlite / mysql / postgres / none)",
+        "sqlite",
       );
       const cleanDbTypeAns = dbTypeAns.toLowerCase().trim();
       if (
+        cleanDbTypeAns === "sqlite" ||
+        cleanDbTypeAns === "sql" ||
+        cleanDbTypeAns === "sqlite3"
+      ) {
+        dbType = "sqlite";
+      } else if (
         cleanDbTypeAns === "postgres" ||
         cleanDbTypeAns === "postgresql" ||
         cleanDbTypeAns === "pg" ||
@@ -72,7 +79,15 @@ class ProjectInit {
         dbType = "none";
       }
 
-      if (dbType !== "none") {
+      if (dbType === "sqlite") {
+        dbName = await ask("Database Name", dbName);
+        const defaultDbFile = `database/${dbName}.db`;
+        dbFile = await ask("Database File Path", defaultDbFile);
+        const dbDir = path.dirname(path.join(this.appDir, dbFile));
+        if (!fs.existsSync(dbDir)) {
+          fs.mkdirSync(dbDir, { recursive: true });
+        }
+      } else if (dbType !== "none") {
         dbName = await ask("Database Name", dbName);
         dbUser = await ask(
           "Database User",
@@ -126,7 +141,7 @@ class ProjectInit {
         }
       });
 
-      const gitignoreContent = `node_modules\nlogs\n.env\npackage-lock.json\n*.db\ntest/\n\nbackups/*.sql\n`;
+      const gitignoreContent = `node_modules\nlogs\n.env\npackage-lock.json\n*.db\n*.sqlite\n*.sqlite-wal\n*.sqlite-shm\n*.db-wal\n*.db-shm\ntest/\n\nbackups/*.sql\nbackups/*.db\n`;
       const gitignoreDest = path.join(this.appDir, ".gitignore");
       const gitignoreSrc = path.join(this.sourceDir, ".gitignore");
 
@@ -149,7 +164,9 @@ class ProjectInit {
           ? "docker-compose.postgres.yml"
           : dbType === "mysql"
             ? "docker-compose.mysql.yml"
-            : "docker-compose.none.yml";
+            : dbType === "sqlite"
+              ? "docker-compose.sqlite.yml"
+              : "docker-compose.none.yml";
       const composeSrc = path.join(
         this.sourceDir,
         "docker",
@@ -198,13 +215,19 @@ class ProjectInit {
           DB_TYPE: dbType,
         };
 
-        if (dbType === "mysql") {
+        if (dbType === "sqlite") {
+          updates.DB_TYPE = "sqlite";
+          updates.DB_FILE = dbFile;
+          updates.DATABASE_URL = `sqlite:${dbFile}`;
+        } else if (dbType === "mysql") {
+          updates.DB_TYPE = "mysql";
           updates.DB_NAME = dbName;
           updates.DB_USER = dbUser;
           updates.DB_PASSWORD = dbPassword;
           updates.DB_PORT = dbPort;
           updates.DATABASE_URL = `mysql://${dbUser}:${dbPassword}@localhost:${dbPort}/${dbName}`;
         } else if (dbType === "postgres") {
+          updates.DB_TYPE = "postgres";
           updates.DB_NAME = dbName;
           updates.DB_USER = dbUser;
           updates.DB_PASSWORD = dbPassword;
@@ -260,7 +283,9 @@ class ProjectInit {
         );
         try {
           let packagesToInstall = ["redis"];
-          if (dbType === "postgres") {
+          if (dbType === "sqlite") {
+            packagesToInstall.push("better-sqlite3");
+          } else if (dbType === "postgres") {
             packagesToInstall.push("pg");
           } else {
             packagesToInstall.push("mysql2");
@@ -365,6 +390,63 @@ class ProjectInit {
   }
 }
 
+/**
+ * Handles adding on-demand modules and dependencies.
+ * @param {string} [feature]
+ */
+function addCommand(feature) {
+  if (!feature) {
+    console.log(chalk.yellow("Usage: npx blue-bird add <feature>"));
+    console.log("Available features to add:");
+    console.log("  upload | multer     - Installs multer for file uploads");
+    console.log("  ws | websocket      - Installs ws for WebSockets");
+    console.log("  redis               - Installs redis for distributed caching and sessions");
+    console.log("  sqlite              - Installs better-sqlite3 for local SQLite database");
+    console.log("  mysql               - Installs mysql2 for MySQL database");
+    console.log("  postgres | pg       - Installs pg for PostgreSQL database");
+    console.log("  bcrypt              - Installs bcrypt for password hashing");
+    console.log("  swagger             - Installs swagger-ui-express");
+    return;
+  }
+
+  const cleanFeature = feature.toLowerCase().trim();
+  const packageMap = {
+    upload: "multer",
+    multer: "multer",
+    ws: "ws",
+    websocket: "ws",
+    websockets: "ws",
+    redis: "redis",
+    sqlite: "better-sqlite3",
+    "better-sqlite3": "better-sqlite3",
+    mysql: "mysql2",
+    mysql2: "mysql2",
+    postgres: "pg",
+    postgresql: "pg",
+    pg: "pg",
+    bcrypt: "bcrypt",
+    swagger: "swagger-ui-express",
+  };
+
+  const pkgName = packageMap[cleanFeature];
+  if (!pkgName) {
+    console.error(chalk.red(`[ERROR] Unknown feature '${feature}'.`));
+    console.log("Available features: upload, ws, redis, sqlite, mysql, postgres, bcrypt, swagger");
+    return;
+  }
+
+  console.log(chalk.cyan(`[INFO] Installing ${pkgName}...`));
+  try {
+    execSync(`npm install ${pkgName}`, {
+      stdio: "inherit",
+      cwd: process.cwd(),
+    });
+    console.log(chalk.green(`[OK] Successfully installed ${pkgName}.`));
+  } catch (err) {
+    console.error(chalk.red(`[ERROR] Failed to install ${pkgName}:`), err.message);
+  }
+}
+
 const initializer = new ProjectInit();
 
 const args = process.argv.slice(2);
@@ -373,4 +455,6 @@ const command = args[0];
 if (command === "route") import("./route.js");
 else if (command === "swagger-install") import("./swagger.js");
 else if (command === "docker") import("./docker.js");
+else if (command === "add") addCommand(args[1]);
 else initializer.run();
+