npm - mwalajs - Versions diffs - 1.0.1 - Mend

mwalajs 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (57) hide show

package/.env +5 -0
package/LICENSE +21 -0
package/README.md +542 -0
package/app.mjs +23 -0
package/bin/backupnewclean.js +162 -0
package/bin/mwala.mjs +176 -0
package/config/createTablesetdb.mjs +38 -0
package/config/createdatabase.mjs +157 -0
package/config/serverConfig.mjs +1 -0
package/controllers/fileController.mjs +15 -0
package/controllers/homeController.mjs +28 -0
package/createProject.mjs +120 -0
package/migrations/20250308115724_create_users.mjs +45 -0
package/migrations/20250724111240_create_transactions.mjs +19 -0
package/migrations/migration_log.json +1 -0
package/models/exampleModel.mjs +5 -0
package/mwala +5 -0
package/mwala.cmd +2 -0
package/mwalajs/index.js +109 -0
package/mwalajs/index.mjs +121 -0
package/mwalajs/package-lock.json +836 -0
package/mwalajs/package.json +16 -0
package/package.json +58 -0
package/public/styles.css +115 -0
package/routes/homeRoutes.mjs +12 -0
package/runMigrations.mjs +137 -0
package/setupMwalajs.mjs +58 -0
package/ujasi/README.md +542 -0
package/ujasi/app.mjs +33 -0
package/ujasi/bin/backupnewclean.js +162 -0
package/ujasi/bin/mwala.mjs +176 -0
package/ujasi/config/createTablesetdb.mjs +38 -0
package/ujasi/config/createdatabase.mjs +156 -0
package/ujasi/config/serverConfig.mjs +1 -0
package/ujasi/controllers/fileController.mjs +15 -0
package/ujasi/controllers/homeController.mjs +28 -0
package/ujasi/models/exampleModel.mjs +5 -0
package/ujasi/mwalajs/index.js +109 -0
package/ujasi/mwalajs/index.mjs +121 -0
package/ujasi/mwalajs/package-lock.json +836 -0
package/ujasi/mwalajs/package.json +16 -0
package/ujasi/package-lock.json +8546 -0
package/ujasi/package.json +58 -0
package/ujasi/public/styles.css +115 -0
package/ujasi/routes/homeRoutes.mjs +12 -0
package/ujasi/runMigrations.mjs +137 -0
package/ujasi/setupMwalajs.mjs +58 -0
package/ujasi/views/about.ejs +159 -0
package/ujasi/views/index.ejs +227 -0
package/ujasi/views/sitemap.xml +1 -0
package/ujasi/views/steps.ejs +514 -0
package/ujasi/views/welcome.ejs +257 -0
package/views/about.ejs +159 -0
package/views/index.ejs +227 -0
package/views/sitemap.xml +1 -0
package/views/steps.ejs +514 -0
package/views/welcome.ejs +257 -0

package/bin/backupnewclean.js ADDED Viewed

@@ -0,0 +1,162 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Dynamically import modules using relative paths
+const { getDbConnection } = await import(pathToFileURL(path.join(__dirname, '../config/createdatabase.mjs')).href);
+const { createTable, dropTable, migrateAll, rollbackLastMigration } = await import(pathToFileURL(path.join(__dirname, '../runMigrations.mjs')).href);
+const { setupMwalajs } = await import(pathToFileURL(path.join(__dirname, '../setupMwalajs.mjs')).href);
+const args = process.argv.slice(2);
+const command = args[0];
+if (!command || command === 'help' || command === 'h') {
+  console.log(`
+  MwalaJS CLI - List of Commands:
+  General:
+  - mwala -v | --version        → Show the version.
+  - mwala help | h              → Show this help.
+  Project Management:
+  - mwala create-project        → Create a new MwalaJS project.
+  - mwala init                  → Initialize MwalaJS.
+  Running App:
+  - mwala serve | app.mjs       → Start the MwalaJS application.
+  Database:
+  - mwala create-db             → Create the database.
+  - mwala create-table <name>   → Create a table.
+  - mwala drop-table <name>     → Drop a table.
+  - mwala migrate all           → Run all migrations.
+  - mwala rollback all          → Roll back last migration.
+  Code Generation:
+  - mwala generate model <name>
+  - mwala generate controller <name>
+  - mwala generate route <name>
+  - mwala generate view <name>
+  - mwala generate midware <name>
+  `);
+  process.exit(0);
+}
+switch (command) {
+  case 'version':
+  case '-v':
+  case '--version':
+    console.log('MwalaJS Version: 1.0.0');
+    process.exit(0);
+  case 'create-project':
+    console.log('Project creation logic goes here.');
+    // await createProject(); // Uncomment when implemented
+    break;
+  case 'serve':
+  case 'app.mjs':
+    try {
+      execSync('node app.mjs', { stdio: 'inherit' });
+    } catch (err) {
+      console.error(`Failed to start app: ${err.message}`);
+      process.exit(1);
+    }
+    break;
+  case 'init':
+    setupMwalajs();
+    break;
+  case 'generate': {
+    const subCommand = args[1]?.toLowerCase();
+    const name = args[2];
+    if (!subCommand || !name) {
+      console.error('Specify both type and name: mwala generate <type> <name>');
+      process.exit(1);
+    }
+    const map = {
+      model: 'models',
+      controller: 'controllers',
+      route: 'routes',
+      view: 'views',
+      midware: 'middlewares'
+    };
+    if (!map[subCommand]) {
+      console.error(`Unknown type '${subCommand}'. Use: ${Object.keys(map).join(', ')}`);
+      process.exit(1);
+    }
+    const filePath = path.join(process.cwd(), map[subCommand], `${name}.mjs`);
+    if (fs.existsSync(filePath)) {
+      console.log(`${subCommand} "${name}" already exists.`);
+      process.exit(1);
+    }
+    const templates = {
+      model: `export const ${name}Model = {};`,
+      controller: `export const ${name}Controller = { get${name}Page: (req, res) => res.render('${name}', { title: '${name} Page' }) };`,
+      route: `import mwalajs from 'mwalajs';\nimport { ${name}Controller } from '../controllers/${name}Controller.mjs';\nconst router = mwalajs.Router();\nrouter.get('/', ${name}Controller.get${name}Page);\nexport { router as ${name}Route };`,
+      view: `<!DOCTYPE html>\n<html lang="en">\n<head><meta charset="UTF-8"><title>${name} Page</title></head>\n<body>\n<h1>${name} View Page</h1>\n</body>\n</html>`,
+      midware: `export const ${name} = (req, res, next) => { next(); };`
+    };
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, templates[subCommand]);
+    console.log(`${subCommand} "${name}" created at ${filePath}`);
+    break;
+  }
+  case 'create-db':
+    getDbConnection().then(() => console.log('Database created.')).catch(err => {
+      console.error(`Database error: ${err.message}`);
+      process.exit(1);
+    });
+    break;
+  case 'create-table':
+    if (!args[1]) {
+      console.error('Specify table name.');
+      process.exit(1);
+    }
+    createTable(args[1]);
+    break;
+  case 'drop-table':
+    if (!args[1]) {
+      console.error('Specify table name.');
+      process.exit(1);
+    }
+    dropTable(args[1]);
+    break;
+  case 'migrate':
+    if (args[1] === 'all') {
+      migrateAll();
+    } else {
+      console.error('Use: mwala migrate all');
+      process.exit(1);
+    }
+    break;
+  case 'rollback':
+    if (args[1] === 'all') {
+      rollbackLastMigration();
+    } else {
+      console.error('Use: mwala rollback all');
+      process.exit(1);
+    }
+    break;
+  default:
+    console.error(`Unknown command: "${command}". Run "mwala help" for options.`);
+    process.exit(1);
+}

package/bin/mwala.mjs ADDED Viewed

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Dynamically import modules using relative paths
+const { getDbConnection } = await import(pathToFileURL(path.join(__dirname, '../config/createdatabase.mjs')).href);
+const { createTable, dropTable, migrateAll, rollbackLastMigration } = await import(pathToFileURL(path.join(__dirname, '../runMigrations.mjs')).href);
+const { setupMwalajs } = await import(pathToFileURL(path.join(__dirname, '../setupMwalajs.mjs')).href);
+const { createProject  } = await import(pathToFileURL(path.join(__dirname, '../createProject.mjs')).href);
+const args = process.argv.slice(2);
+const command = args[0];
+if (!command || command === 'help' || command === 'h') {
+  console.log(`
+    MwalaJS CLI - List of Commands:
+  General Commands:
+  - mwala -v | mwala --version → Show the MwalaJS version.
+  - mwala help | mwala h       → Show this help message.
+  Project Management:
+  - mwala create-project       → Create a new MwalaJS project.
+  - mwala init                 → Initialize MwalaJS in the current project.
+  Running the Application:
+  - mwala serve | mwala app.mjs → Start the MwalaJS application.
+  Database Operations:
+  - mwala create-db            → Create the database specified in the .env file.
+  - mwala create-table <name>  → Create a specific database table.
+  - mwala drop-table <name>    → Drop a specific database table.
+  - mwala migrate all          → Run all pending migrations.
+  Code Generation:
+  - mwala generate model <name>       → Create a new model.
+  - mwala generate controller <name>  → Create a new controller.
+  - mwala generate route <name>       → Create a new route.
+  - mwala generate view <name>        → Create a new view file.
+  - mwala generate midware <name>     → Create a new middleware.
+   Use "mwala <command>" to execute a command.
+  `);
+  process.exit(0);
+}
+switch (command) {
+  case 'version':
+  case '-v':
+  case '--version':
+    console.log('MwalaJS Version: 1.0.1');
+    process.exit(0);
+  case 'create-project':
+    createProject();
+    break;
+  case 'serve':
+  case 'app.mjs':
+    try {
+      execSync('node app.mjs', { stdio: 'inherit' });
+    } catch (error) {
+      console.error(` Failed to run the app: ${error.message}`);
+      process.exit(1);
+    }
+    break;
+  case 'init':
+    setupMwalajs();
+    break;
+  case 'generate': {
+    const subCommand = args[1]?.toLowerCase();
+    const name = args[2];
+    if (!subCommand || !name) {
+      console.log(' Please specify both subCommand and name.');
+      process.exit(1);
+    }
+    const paths = {
+      model: 'models',
+      controller: 'controllers',
+      route: 'routes',
+      view: 'views',
+      midware: 'middlewares'
+    };
+    if (!paths[subCommand]) {
+      console.log(` Invalid subCommand: ${subCommand}. Valid options are: ${Object.keys(paths).join(', ')}`);
+      process.exit(1);
+    }
+    const filePath = path.join(process.cwd(), paths[subCommand], `${name}.mjs`);
+    if (fs.existsSync(filePath)) {
+      console.log(` ${name} ${subCommand} already exists.`);
+      process.exit(1);
+    }
+    let content = '';
+    switch (subCommand) {
+      case 'model':
+        content = `export const ${name}Model = {};`;
+        break;
+      case 'controller':
+        content = `export const ${name}Controller = { get${name}Page: (req, res) => { res.render('${name}', { title: '${name} Page' }); } };`;
+        break;
+      case 'route':
+        content = `import mwalajs from 'mwalajs';\nimport { ${name}Controller } from '../controllers/${name}Controller.mjs';\nconst router = mwalajs.Router();\nrouter.get('/', ${name}Controller.get${name}Page);\nexport { router as ${name}Route };`;
+        break;
+      case 'view':
+        content = `<!DOCTYPE html>\n<html lang='en'>\n<head>\n  <meta charset='UTF-8'>\n  <title>${name} Page</title>\n</head>\n<body>\n  <h1>${name} View Page</h1>\n</body>\n</html>`;
+        break;
+      case 'midware':
+        content = `export const ${name} = (req, res, next) => { next(); };`;
+        break;
+    }
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+    console.log(` ${name} ${subCommand} created successfully in ${paths[subCommand]}/.`);
+    break;
+  }
+  case 'create-db':
+    getDbConnection().then(() => console.log('Database created.')).catch(err => {
+      console.error(` Failed to create database: ${err.message}`);
+      process.exit(1);
+    });
+    break;
+  case 'create-table':
+    if (!args[1]) {
+      console.error(' Please specify a table name.');
+      process.exit(1);
+    }
+    createTable(args[1]);
+    break;
+  case 'drop-table':
+    if (!args[1]) {
+      console.error(' Please specify a table name.');
+      process.exit(1);
+    }
+    dropTable(args[1]);
+    break;
+  case 'migrate':
+    if (args[1] === 'all') {
+      migrateAll();
+    } else {
+      console.error(' Invalid migration command. Use: mwala migrate all');
+      process.exit(1);
+    }
+    break;
+    case 'rollback':
+    if (args[1] === 'all') {
+      rollbackLastMigration();
+    } else {
+      console.error(' Invalid migration command. Use: mwala roll-back all');
+      process.exit(1);
+    }
+    break;
+  default:
+    console.error(` Unknown command: ${command}. Run "mwala help" to see available commands.`);
+    process.exit(1);
+}

package/config/createTablesetdb.mjs ADDED Viewed

@@ -0,0 +1,38 @@
+import Sequelize from 'sequelize';
+import mongoose from 'mongoose';
+import dotenv from 'dotenv';
+dotenv.config();
+const dbType = process.env.DB_TYPE || 'mysql';
+let sequelize;
+let mongooseConnection;
+/**
+ * ✅ Fungua connection kulingana na aina ya database
+ */
+if (['mysql', 'postgres', 'sqlite'].includes(dbType)) {
+  sequelize = new Sequelize({
+    dialect: dbType,
+    host: process.env.DB_HOST || 'localhost',
+    database: process.env.DB_NAME,
+    username: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    port: process.env.DB_PORT || (dbType === 'mysql' ? 3306 : 5432),
+    storage: dbType === 'sqlite' ? process.env.DB_STORAGE || 'database.sqlite' : undefined,
+    logging: false
+  });
+} else if (dbType === 'mongodb') {
+  const mongoUri = `mongodb://${process.env.DB_HOST || 'localhost'}:${process.env.DB_PORT || 27017}/${process.env.DB_NAME}`;
+  mongooseConnection = mongoose.connect(mongoUri, {
+    useNewUrlParser: true,
+    useUnifiedTopology: true
+  });
+} else {
+  throw new Error('Unsupported database type. Check your .env configuration.');
+}
+export { sequelize, mongooseConnection };

package/config/createdatabase.mjs ADDED Viewed

@@ -0,0 +1,157 @@
+import fs from 'fs';
+import readlineSync from 'readline-sync';
+import mysql from 'mysql2/promise';
+import { MongoClient } from 'mongodb';
+import sqlite3 from 'sqlite3';
+import pkg from 'pg';
+import dotenv from 'dotenv';
+const { Client } = pkg;
+// Function to reset the .env file before processing
+const resetEnvFile = () => {
+  try {
+    fs.writeFileSync('.env', '', 'utf8'); // Empty the .env file
+    console.log(' Cleared .env file.');
+  } catch (error) {
+    console.error(' Failed to clear .env file:', error.message);
+  }
+};
+// Function to write data to the .env file
+const writeToEnv = (data) => {
+  const envContent = Object.keys(data)
+    .map(key => `${key}=${data[key]}`)
+    .join('\n');
+  fs.writeFileSync('.env', envContent, 'utf8');
+};
+// Function to create the database connection
+export const getDbConnection = async () => {
+  resetEnvFile(); // Clear .env file before proceeding
+  dotenv.config(); // Reload the (now empty) .env file
+  // Supported database types
+  const supportedDbTypes = {
+    mysql: 'mysql',
+    my: 'mysql',
+    postgresql: 'postgresql',
+    pg: 'postgresql',
+    mongodb: 'mongodb',
+    mn: 'mongodb',
+    sqlite: 'sqlite',
+    sq: 'sqlite'
+  };
+  let dbType;
+  while (true) {
+    dbType = readlineSync.question('Enter the database type (mysql/my, postgresql/pg, mongodb/mn, sqlite/sq): ').toLowerCase();
+    if (supportedDbTypes[dbType]) {
+      dbType = supportedDbTypes[dbType]; // Normalize input
+      break;
+    } else {
+      console.log('❌ Invalid database type. Please enter a valid option.');
+    }
+  }
+  // Prompt for database details
+  const dbName = readlineSync.question('Enter the database name: ').trim();
+  if (!dbName) {
+    console.log(' Database name cannot be empty.');
+    return;
+  }
+  let dbHost = 'localhost';
+  let dbUser = '';
+  let dbPassword = '';
+  if (dbType !== 'sqlite') {
+    dbHost = readlineSync.question('Enter the database host (default: localhost): ') || 'localhost';
+    dbUser = readlineSync.question('Enter the database user: ').trim();
+    dbPassword = readlineSync.question('Enter the database password: ', { hideEchoBack: true }).trim();
+  }
+  // Save valid details to .env
+  const envData = {
+    DB_TYPE: dbType,
+    DB_NAME: dbName,
+    DB_HOST: dbHost,
+    DB_USER: dbUser,
+    DB_PASSWORD: dbPassword,
+  };
+  writeToEnv(envData);
+  console.log(' Database credentials saved to .env file.');
+  let connection;
+  try {
+    if (dbType === 'mysql') {
+      const tempConnection = await mysql.createConnection({
+        host: dbHost,
+        user: dbUser,
+        password: dbPassword,
+      });
+      const [rows] = await tempConnection.query(`SHOW DATABASES LIKE '${dbName}'`);
+      if (rows.length === 0) {
+        await tempConnection.query(`CREATE DATABASE \`${dbName}\``);
+        console.log(` MySQL Database "${dbName}" created successfully.`);
+      } else {
+        console.log(` MySQL Database "${dbName}" already exists.`);
+      }
+      connection = await mysql.createConnection({
+        host: dbHost,
+        user: dbUser,
+        password: dbPassword,
+        database: dbName,
+      });
+      await tempConnection.end();
+    } else if (dbType === 'postgresql') {
+      const tempClient = new Client({
+        host: dbHost,
+        user: dbUser,
+        password: dbPassword,
+      });
+      await tempClient.connect();
+      const checkDb = await tempClient.query(`SELECT datname FROM pg_database WHERE datname = '${dbName}'`);
+      if (checkDb.rows.length === 0) {
+        await tempClient.query(`CREATE DATABASE ${dbName}`);
+        console.log(` PostgreSQL Database "${dbName}" created successfully.`);
+      } else {
+        console.log(` PostgreSQL Database "${dbName}" already exists.`);
+      }
+      await tempClient.end();
+      connection = new Client({
+        host: dbHost,
+        user: dbUser,
+        password: dbPassword,
+        database: dbName,
+      });
+      await connection.connect();
+    } else if (dbType === 'mongodb') {
+      connection = await MongoClient.connect(`mongodb://${dbHost}:27017`);
+      console.log(` MongoDB connection to "${dbName}" established.`);
+    } else if (dbType === 'sqlite') {
+      connection = new sqlite3.Database(`./${dbName}.sqlite`);
+      console.log(` SQLite Database "${dbName}.sqlite" is ready.`);
+    } else {
+      throw new Error(` Unsupported DB type: ${dbType}`);
+    }
+  } catch (error) {
+    console.error(` Failed to create database: ${error.message}`);
+    return;
+  }
+  return connection;
+};

package/config/serverConfig.mjs ADDED Viewed

	@@ -0,0 +1 @@
1	+

package/controllers/fileController.mjs ADDED Viewed

@@ -0,0 +1,15 @@
+import fs from 'fs';
+import path from 'path';
+export const fileController = {
+  uploadFile: (req, res) => {
+    const file = req.file;
+    if (file) {
+      const uploadPath = path.join(__dirname, '../public/uploads/', file.originalname);
+      fs.writeFileSync(uploadPath, file.buffer);
+      res.send('File uploaded successfully');
+    } else {
+      res.status(400).send('No file uploaded');
+    }
+  },
+};

package/controllers/homeController.mjs ADDED Viewed

@@ -0,0 +1,28 @@
+//homeController.mjs
+export const homeController = {
+  getHomePage: (req, res) => {
+    res.render('index', { title: 'Welcome to MwalaJS MVC' });
+  }
+};
+export const Steps = {
+getSteps: (req, res) => {
+  res.render('steps', { title: 'Welcome to MwalaJS MVC' });
+}
+};
+export const welcome = {
+  getwelcome: (req, res) => {
+    res.render('welcome', { title: 'Welcome to MwalaJS MVC' });
+  }
+  };
+  export const about = {
+    getabout: (req, res) => {
+      res.render('about', { title: 'Welcome to MwalaJS MVC' });
+    }
+    };

package/createProject.mjs ADDED Viewed

@@ -0,0 +1,120 @@
+import fs from 'fs-extra';
+import path from 'path';
+import readline from 'readline';
+import { exec } from 'child_process';
+import os from 'os';
+/**
+ * Detect base source path from environment or defaults
+ */
+function getMwalajsPath() {
+    const envPath = process.env.MWALAJSPATH;
+    if (envPath && fs.existsSync(envPath)) return envPath;
+    const defaultPaths = {
+        win32: 'C:\\Program Files\\mwalajs',
+        linux: '/usr/local/lib/mwalajs',
+        darwin: '/usr/local/lib/mwalajs'
+    };
+    const fallback = defaultPaths[os.platform()];
+    if (fs.existsSync(fallback)) return fallback;
+    console.warn(" mwalajs source path not found. Using current directory.");
+    return process.cwd(); // fallback
+}
+/**
+ * Function to create a new project folder, copy required files, and auto-enter the directory.
+ */
+async function createProject() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    rl.question(" Enter the name of the new project: ", async (projectName) => {
+        const currentDir = process.cwd();
+        const newProjectPath = path.join(currentDir, projectName);
+        const mwalajsSourcePath = getMwalajsPath();
+        try {
+            if (fs.existsSync(newProjectPath)) {
+                console.error(` Error: Folder '${projectName}' already exists.`);
+                rl.close();
+                return;
+            }
+            console.log(` Creating folder: ${newProjectPath}...`);
+            fs.mkdirSync(newProjectPath);
+            const itemsToCopy = [
+                "app.mjs", "controllers", "mwalajs", "routes",
+                "views", "middlewares", "models", "package.json",
+                "README.md", "public"
+            ];
+            for (const item of itemsToCopy) {
+                const src = path.join(mwalajsSourcePath, item);
+                const dest = path.join(newProjectPath, item);
+                if (fs.existsSync(src)) {
+                    console.log(` Copying '${item}'...`);
+                    fs.copySync(src, dest);
+                } else {
+                    console.warn(` '${item}' not found in source. Skipping...`);
+                }
+            }
+            console.log(` Project '${projectName}' created successfully!`);
+            console.log(` Location: ${newProjectPath}`);
+            // Open terminal automatically
+            const platform = os.platform();
+            if (platform === 'win32') {
+                exec(`start cmd.exe /K "cd /d ${newProjectPath}"`);
+            } else if (platform === 'darwin') {
+                exec(`open -a Terminal "${newProjectPath}"`);
+            } else if (platform === 'linux') {
+                // Try gnome-terminal, x-terminal-emulator, or konsole
+                const termCmds = [
+                    `gnome-terminal -- bash -c 'cd "${newProjectPath}" && bash'`,
+                    `x-terminal-emulator -e 'bash -c "cd \\"${newProjectPath}\\"; exec bash"'`,
+                    `konsole --workdir "${newProjectPath}"`
+                ];
+                let opened = false;
+                for (const cmd of termCmds) {
+                    try {
+                        exec(cmd, (error) => {
+                            if (!error && !opened) opened = true;
+                        });
+                        break;
+                    } catch {}
+                }
+                if (!opened) {
+                    console.log(" Please manually open the folder:", newProjectPath);
+                }
+            } else {
+                console.log(" Unknown OS. Please open manually:", newProjectPath);
+            }
+        } catch (err) {
+            console.error(" Project creation failed:", err.message);
+        } finally {
+            rl.close();
+        }
+    });
+}
+// Export if used as a module
+export { createProject };
+// Run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    createProject();
+}