@dhruvinjs/appinit 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dhruvin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/actions/setup_linting.js

@@ -0,0 +1 @@
+export {};

package/dist/constants.js

@@ -0,0 +1,71 @@
+export const restApi_deps = [
+    "express",
+    "dotenv",
+    "cors",
+    "jsonwebtoken",
+    "helmet",
+    "pino",
+    "pino-http", //middleware for the http
+    "zod",
+    "pino-pretty",
+];
+export const restApi_dev_deps = [
+    "nodemon",
+    "eslint@^9.0.0", // Force version 9
+    "@eslint/js@^9.0.0", // Match with eslint
+    "prettier",
+    "globals@^15.0.0", // Helps ESLint understand Node/Browser variables
+];
+export const restApi_deps_typescript = [
+    "@types/express",
+    "@types/jsonwebtoken",
+    "@types/node",
+    "typescript",
+    "@types/cors",
+    "ts-node",
+    "typescript-eslint@^8.0.0", // Works perfectly with v9
+];
+export const websocket_project_deps = [
+    {
+        package: "ws",
+        deps: ["ws"],
+    },
+    {
+        package: "socket.io",
+        deps: ["socket.io"],
+    },
+];
+export const db_deps = [
+    {
+        db: "none",
+        deps: [],
+    },
+    { db: "mongo", deps: ["mongoose"] },
+    { db: "postgresql_prisma", deps: ["@prisma/client@^6.0.0"] },
+];
+export const db_deps_dev = [
+    { db: "none", deps: [] },
+    { db: "mongo", deps: [] },
+    { db: "postgresql_prisma", deps: ["prisma@^6.0.0"] },
+];
+export const restApi_dirs = [
+    "controller",
+    "utils",
+    "models",
+    "routes",
+    "services",
+    "config",
+];
+export const package_manager_env = [
+    { package_manager: "npm", deps: ["npm", "npx"] },
+    { package_manager: "pnpm,", deps: ["pnpm"] },
+    { package_manager: "yarn", deps: ["yarn"] },
+];
+export const template_flags = [
+    "--ts-ws",
+    "--ts-rest",
+    "--ts-io",
+    "--js-rest",
+    "--js-ws",
+    "--js-io",
+];

package/dist/generator/engine.js

@@ -0,0 +1 @@
+export {};

package/dist/generator/shell.js

@@ -0,0 +1,204 @@
+import { execa } from "execa";
+import { oraPromise } from "ora";
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { restApi_deps, restApi_deps_typescript, db_deps, db_deps_dev, restApi_dirs, restApi_dev_deps, websocket_project_deps, } from "../constants.js";
+import { removeProjectDirectory, showSuccessfulMessage, updatePackageJson, updateTsconfig, isToolInstalled, } from "../utils/utils.js";
+import { write_rest_templates } from "./template_engine.js";
+let current_project_path = null;
+export async function setup_restApi_project(project_config) {
+    const pm = project_config.packageManager || "npm";
+    const pmInstall = pm === "yarn" ? "add" : "install";
+    // Set the current project path for SIGINT handler
+    current_project_path = project_config.path;
+    try {
+        // Check if package manager is installed
+        if (!(await isToolInstalled(pm))) {
+            throw new Error(`Package manager "${pm}" is not installed or not in your PATH.`);
+        }
+        if (!fs.existsSync(project_config.path)) {
+            fs.mkdirSync(project_config.path, { recursive: true });
+        }
+        // Handle package manager init differently - pnpm and yarn don't support -y flag
+        const initArgs = pm === "npm" ? ["init", "-y"] : ["init"];
+        await oraPromise(execa(pm, initArgs, { cwd: project_config.path }), {
+            text: "Initializing project...",
+            successText: chalk.green(`${pm} initialized`),
+        });
+        // Step 2: Set package name
+        await oraPromise(execa(pm, ["pkg", "set", `name=${project_config.name}`], {
+            cwd: project_config.path,
+        }), {
+            text: "Setting project name...",
+            successText: chalk.green(`Project name set to "${project_config.name}"`),
+        });
+        // Step 3: Install dependencies
+        const deps = restApi_deps;
+        const dbDependenciesObj = db_deps.find((d) => d.db === project_config.db);
+        const dbDeps = dbDependenciesObj?.deps ?? [];
+        const allDeps = [...deps, ...dbDeps];
+        await oraPromise(execa(pm, [pmInstall, ...allDeps], { cwd: project_config.path }), {
+            text: `Installing dependencies (${allDeps.length} packages)...`,
+            successText: chalk.green("Dependencies installed"),
+        });
+        // Step 4: Create directories
+        await oraPromise(generate_restApis_folder(project_config.path), {
+            text: "Creating project structure...",
+            successText: chalk.green("Directories created"),
+        });
+        // Step 5: Install dev dependencies
+        if (project_config.language === "ts") {
+            // console.log("typescript project");
+            await oraPromise(setup_restApiforTypeScript_project(project_config.path, pm, pmInstall), {
+                text: "Setuping typescript compiler",
+                successText: chalk.green("Ts project enabled"),
+            });
+            await oraPromise(updateTsconfig(project_config.path), {
+                text: "Configuring tsconfig.json...",
+                successText: chalk.green("tsconfig.json updated"),
+            });
+        }
+        const devDeps = [];
+        const dbDevDependenciesObj = db_deps_dev.find((d) => d.db === project_config.db);
+        const dbDev_Deps = dbDevDependenciesObj?.deps ?? [];
+        devDeps.push(...dbDev_Deps);
+        await oraPromise(execa(pm, [pmInstall, "-D", ...devDeps, ...restApi_dev_deps], {
+            cwd: project_config.path,
+        }), {
+            text: `Installing dev dependencies (${devDeps.length + restApi_dev_deps.length} packages)...`,
+            successText: chalk.green("Dev dependencies installed"),
+        });
+        if (project_config.db === "postgresql_prisma") {
+            await oraPromise(execa("npx", ["prisma", "init"], {
+                cwd: project_config.path,
+            }), {
+                text: `Setting up prisma ...`,
+                successText: chalk.green("Prisma Setup done"),
+            });
+        }
+        // Step 6: Setup websockets if template includes websocket
+        if (project_config.template.includes("websocket")
+            && project_config.websocket_package) {
+            await oraPromise(setup_websockets_project(project_config.websocket_package, project_config.language, project_config.path, pm, pmInstall), {
+                text: `Setting up ${project_config.websocket_package}...`,
+                successText: chalk.green(`${project_config.websocket_package} configured`),
+            });
+        }
+        await oraPromise(updatePackageJson(project_config.path, project_config.language), {
+            text: `Updating package.json with dev scripts...`,
+            successText: chalk.green("Updated Package.json"),
+        });
+        if (!project_config.skipGit) {
+            try {
+                await oraPromise(execa(`git`, ["init"], { cwd: project_config.path }), {
+                    successText: chalk.green("Initialized git repositary"),
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(chalk.yellow(`Warning: git initialization failed. Continuing without git repo. Reason: ${message}`));
+            }
+        }
+        else {
+            console.log(chalk.yellow("⚠️  Skipping git initialization (--no-git flag)"));
+        }
+        await oraPromise(write_rest_templates({
+            ...project_config,
+            path: project_config.path,
+        }), {
+            successText: chalk.green("Boilerplate code wrote successfully"),
+        });
+        // Final success message
+        showSuccessfulMessage(project_config);
+        // Clear the current project path on success
+        current_project_path = null;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Fatal: ${message}`));
+        await cleanupProjectDirectoryOnFailure(project_config.path);
+        // Clear the current project path after cleanup
+        current_project_path = null;
+        process.exit(1);
+    }
+}
+export async function cleanupProjectDirectoryOnFailure(projectDirPath) {
+    try {
+        await removeProjectDirectory(projectDirPath);
+        console.log(chalk.yellow(`Removed directory: ${projectDirPath}`));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(chalk.yellow(`Warning: failed to clean up project directory. Directory kept at "${projectDirPath}". Reason: ${message}`));
+    }
+}
+export async function generate_restApis_folder(project_path) {
+    try {
+        const srcDir = path.join(project_path, "src");
+        fs.mkdirSync(srcDir, { recursive: true });
+        const dirs = restApi_dirs.map((dir) => path.join("src", dir));
+        for (const dir of dirs) {
+            fs.mkdirSync(path.join(project_path, dir), { recursive: true });
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to create directories: ${error}`);
+    }
+}
+export async function setup_restApiforTypeScript_project(project_path, pm = "npm", pmInstall = "install") {
+    try {
+        await execa(pm, [pmInstall, "-D", ...restApi_deps_typescript], {
+            cwd: project_path,
+        });
+        await execa("npx", ["tsc", "--init"], { cwd: project_path });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to set up the TypeScript project for rest_api template: ${message}`);
+    }
+}
+export async function setup_websockets_project(websocket_package, language, project_path, pm = "npm", pmInstall = "install") {
+    try {
+        const dependencies = [];
+        const wsDeps = websocket_project_deps.find((d) => d.package === websocket_package);
+        if (!wsDeps) {
+            throw new Error(`Unsupported database type: ${websocket_package}`);
+        }
+        dependencies.push(...wsDeps.deps);
+        if (language === "ts" && websocket_package === "ws") {
+            await execa(pm, [pmInstall, "-D", "@types/ws"], {
+                cwd: project_path,
+            });
+        }
+        await execa(pm, [pmInstall, ...dependencies], { cwd: project_path });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === "ExitPromptError") {
+                console.log("\n⚠️ Process Cancelled by user");
+                process.exit(0);
+            }
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to set up websocket project: ${message}`);
+    }
+}
+process.on("SIGINT", async () => {
+    console.log(chalk.yellow("\n⚠️ Process cancelled by user (Ctrl+C detected)"));
+    if (current_project_path) {
+        console.log(chalk.yellow("Cleaning up project directory..."));
+        await cleanupProjectDirectoryOnFailure(current_project_path);
+        current_project_path = null;
+    }
+    process.exit(0);
+});
+process.on("SIGTERM", async () => {
+    console.log(chalk.yellow("\n⚠️ Process cancelled by user (Ctrl+D detected)"));
+    if (current_project_path) {
+        console.log(chalk.yellow("Cleaned Up Project Directory"));
+        await cleanupProjectDirectoryOnFailure(current_project_path);
+        current_project_path = null;
+    }
+    process.exit(0);
+});

package/dist/generator/template_engine.js

@@ -0,0 +1,121 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fsExtra from "fs-extra";
+import ejs from "ejs";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export async function write_rest_templates(project_config) {
+    const isTs = project_config.language === "ts";
+    const template_base_path = give_template_file_path();
+    const languageDir = isTs ? "typescript" : "javascript";
+    //sourceRoot means it will go to the template/base then langDir=> js or ts
+    const sourceRoot = path.join(template_base_path, languageDir);
+    const projectRoot = project_config.path;
+    const files = await listTemplateFiles(sourceRoot);
+    for (const file of files) {
+        if (!shouldRenderTemplate(file, isTs)) {
+            continue;
+        }
+        const relativePath = path.relative(sourceRoot, file);
+        const targetPath = mapTemplatePathToTarget(relativePath, projectRoot, isTs);
+        await renderTemplateFile(file, targetPath, project_config);
+    }
+    await writeCommonFiles(template_base_path, projectRoot, project_config);
+    if (project_config.Dockerfile) {
+        const docker_template_root = give_dockerfile_path();
+        const docker_template_path = path.join(docker_template_root, languageDir, "Dockerfile.ejs");
+        const docker_target_path = path.join(projectRoot, "Dockerfile");
+        await write_dockerfile_template(project_config, docker_template_path, docker_target_path);
+    }
+    if (project_config.template.includes("websocket")) {
+        await write_websocket_index(project_config, template_base_path, projectRoot, isTs);
+    }
+}
+// dockerfile logic
+async function write_dockerfile_template(project_config, docker_template_path, docker_target_path) {
+    if (!project_config.Dockerfile) {
+        throw new Error("Dockerfile is not selected in project_config");
+    }
+    await renderTemplateFile(docker_template_path, docker_target_path, project_config);
+}
+//websocket file logic
+async function write_websocket_index(project_config, templateBase, projectRoot, isTs) {
+    if (!project_config.websocket_package) {
+        throw new Error("websocket_package is required for websocket templates");
+    }
+    const languageDir = isTs ? "typescript" : "javascript";
+    const ext = isTs ? "ts" : "js";
+    const websocketIndex = path.join(templateBase, "websockets", project_config.websocket_package, languageDir, `index.${ext}.ejs`);
+    const targetIndex = isTs
+        ? path.join(projectRoot, "src", `index.${ext}`)
+        : path.join(projectRoot, `index.${ext}`);
+    await renderTemplateFile(websocketIndex, targetIndex, project_config);
+}
+function get_template_package_root() {
+    const pkg_json_path = require.resolve("appinit-templates/package.json");
+    return path.dirname(pkg_json_path);
+}
+function give_template_file_path() {
+    return path.join(get_template_package_root(), "base");
+}
+function give_dockerfile_path() {
+    return path.join(get_template_package_root(), "features", "docker", "base");
+}
+async function listTemplateFiles(root) {
+    const entries = await fsExtra.readdir(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(root, entry.name);
+        // first full path of file will be taken and recursion has started in which basically
+        // it will go to a dir and there is a nested dir it will go into that and basically will not stop
+        // until it finds a file if file is found then push it into the file folder
+        if (entry.isDirectory()) {
+            files.push(...(await listTemplateFiles(fullPath)));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".ejs")) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function shouldRenderTemplate(filePath, isTs) {
+    const fileName = path.basename(filePath);
+    if (!isTs && fileName.endsWith(".ts.ejs")) {
+        return false;
+    }
+    return true;
+}
+//function that removes the ejs and gives files extension according to language selected
+function mapTemplatePathToTarget(relativePath, projectRoot, isTs) {
+    const parts = relativePath.split(path.sep).map((part) => {
+        if (part.startsWith(",")) {
+            return `.${part.slice(1)}`;
+        }
+        if (part.endsWith(".ejs")) {
+            return part.replace(/\.ejs$/, "");
+        }
+        return part;
+    });
+    let mapped = path.join(projectRoot, ...parts);
+    if (!isTs && relativePath === path.join("src", "index.js.ejs")) {
+        mapped = path.join(projectRoot, "index.js");
+    }
+    if (!isTs && mapped.endsWith(".ts")) {
+        mapped = mapped.replace(/\.ts$/, ".js");
+    }
+    return mapped;
+}
+//actual code generation where the ejs will render the boilerplate file and write the logic using async await
+async function renderTemplateFile(srcPath, destPath, data) {
+    const templateData = { ...data, database: data.db };
+    const rendered = await ejs.renderFile(srcPath, templateData, { async: true });
+    await fsExtra.ensureDir(path.dirname(destPath));
+    await fsExtra.writeFile(destPath, rendered, "utf8");
+}
+async function writeCommonFiles(templateBase, projectRoot, project_config) {
+    const commonRoot = path.join(templateBase, "common");
+    const gitignore = path.join(commonRoot, ",gitignore.ejs");
+    await renderTemplateFile(gitignore, path.join(projectRoot, ".gitignore"), project_config);
+    const envFile = path.join(commonRoot, "env.ejs");
+    await renderTemplateFile(envFile, path.join(projectRoot, ".env"), project_config);
+}

package/dist/index.js

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+const program = new Command();
+import inquirer from "inquirer";
+import { checkEnv, generateRandomNames, getSafeProjectPath, isToolInstalled, } from "./utils/utils.js";
+import { setup_restApi_project } from "./generator/shell.js";
+import { package_manager_env, db_deps_dev, template_flags, } from "./constants.js";
+function validateRawFlags(args) {
+    if (args.length >= 300) {
+        throw new Error("Input is too long! Are You trying to hack me or what?");
+    }
+    const found_presets = args.filter((flags) => template_flags.includes(flags));
+    //if no flag provided then I can ask the user only that bro what template do you want
+    if (found_presets.length > 1) {
+        // console.log(template_flag);
+        throw new Error("Cannot have 2 template flags in one command");
+    }
+    const allowed_dbs = db_deps_dev.map((items) => items.db);
+    const found_dbs = args.filter((dbs) => allowed_dbs.includes(dbs));
+    if (found_dbs.length > 1) {
+        throw new Error(`Cannot have 2 database choices in one command. You Choose: ${found_dbs.join(",")}`);
+    }
+    const allowed_pms = package_manager_env.map((items) => items.package_manager);
+    const found_pms = args.filter((pms) => allowed_pms.includes(pms));
+    if (found_pms.length > 1) {
+        throw new Error(`Cannot have 2 package_manager choices in one command. You Choose: ${found_pms.join(",")}`);
+    }
+    if (args.includes("--docker") && args.includes("--no-docker")) {
+        throw new Error("Docker and No-Docker Flag cannot exist in same command");
+    }
+}
+program
+    .name("appinit")
+    .description("Generate production-ready backend projects")
+    .version("1.0.0")
+    // Preset flags
+    .option("--ts", "TypeScript + REST API (default template)")
+    .option("--js", "JavaScript + REST API (default template)")
+    .option("--ts-rest", "TypeScript + REST API")
+    .option("--ts-ws", "TypeScript + WebSocket (ws package)")
+    .option("--ts-io", "TypeScript + Socket.io")
+    .option("--js-rest", "JavaScript + REST API")
+    .option("--js-ws", "JavaScript + WebSocket (ws package)")
+    .option("--js-io", "JavaScript + Socket.io")
+    // Granular configuration flags
+    .option("--template <type>", "Template type: rest_api or websocket+rest_api")
+    .option("--lang <language>", "Language: js or ts")
+    .option("--db <database>", "Database: none, mongo, or postgresql_prisma")
+    .option("--ws <package>", "WebSocket package: ws or socket.io")
+    .option("--docker", "Include Dockerfile")
+    .option("--no-docker", "Skip Dockerfile")
+    // Utility flags
+    .option("--no-git", "Skip git initialization")
+    .option("--pm <manager>", "Package manager: npm, pnpm, or yarn")
+    .addHelpText("after", `
+Examples:
+  $ appinit my-app --ts-rest
+  $ appinit my-app --ts-io --db mongo --docker
+  $ appinit my-app --js-ws --db none --no-git
+  $ appinit my-app --template rest_api --lang ts --db postgresql_prisma
+    `)
+    .action(async (options) => {
+    try {
+        // validateRawCommand(process.argv.slice(2).join(" "));
+        //process.argv prints everythign you typed into the terminal like
+        // npm init -y, here slice means create a new array after 2nd argument
+        // npx appinit --ts-ws mongo => this will only create a new array
+        // of ['--ts-ws','mongo']
+        validateRawFlags(process.argv.slice(2));
+        const flagConfig = {};
+        // Handle preset flags
+        const presets = [
+            { flag: options.ts, template: "rest_api", language: "ts" },
+            { flag: options.js, template: "rest_api", language: "js" },
+            { flag: options.tsRest, template: "rest_api", language: "ts" },
+            {
+                flag: options.tsWs,
+                template: "websocket+rest_api",
+                language: "ts",
+                websocketPackage: "ws",
+            },
+            {
+                flag: options.tsIo,
+                template: "websocket+rest_api",
+                language: "ts",
+                websocketPackage: "socket.io",
+            },
+            { flag: options.jsRest, template: "rest_api", language: "js" },
+            {
+                flag: options.jsWs,
+                template: "websocket+rest_api",
+                language: "js",
+                websocketPackage: "ws",
+            },
+            {
+                flag: options.jsIo,
+                template: "websocket+rest_api",
+                language: "js",
+                websocketPackage: "socket.io",
+            },
+        ];
+        const activePresets = presets.filter((p) => p.flag);
+        if (activePresets.length === 1) {
+            const preset = activePresets[0];
+            if (preset) {
+                flagConfig.template = preset.template;
+                flagConfig.language = preset.language;
+                if (preset.websocketPackage) {
+                    flagConfig.websocket_package = preset.websocketPackage;
+                }
+            }
+        }
+        // Handle granular flags (they override presets)
+        if (options.template) {
+            const validTemplates = ["rest_api", "websocket+rest_api"];
+            if (!validTemplates.includes(options.template)) {
+                console.error(`❌ Error: Invalid template "${options.template}". Use: rest_api or websocket+rest_api`);
+                process.exit(1);
+            }
+            flagConfig.template = options.template;
+        }
+        if (options.lang) {
+            const validLangs = ["js", "ts"];
+            if (!validLangs.includes(options.lang)) {
+                console.error(`❌ Error: Invalid language "${options.lang}". Use: js or ts`);
+                process.exit(1);
+            }
+            flagConfig.language = options.lang;
+        }
+        if (options.db) {
+            const validDbs = ["none", "mongo", "postgresql_prisma"];
+            if (!validDbs.includes(options.db)) {
+                console.error(`❌ Error: Invalid database "${options.db}". Use: none, mongo, or postgresql_prisma`);
+                process.exit(1);
+            }
+            flagConfig.database = options.db;
+        }
+        if (options.ws) {
+            const validWs = ["ws", "socket.io"];
+            if (!validWs.includes(options.ws)) {
+                console.error(`❌ Error: Invalid websocket package "${options.ws}". Use: ws or socket.io`);
+                process.exit(1);
+            }
+            flagConfig.websocket_package = options.ws;
+        }
+        if (options.pm) {
+            const validPm = ["npm", "pnpm", "yarn"];
+            if (!validPm.includes(options.pm)) {
+                console.error(`❌ Error: Invalid package manager "${options.pm}". Use: npm, pnpm, or yarn`);
+                process.exit(1);
+            }
+        }
+        // Commander negated options can set defaults implicitly.
+        // Only treat docker as explicitly configured when the user passed a docker flag.
+        const dockerFlagProvided = process.argv.includes("--docker")
+            || process.argv.includes("--no-docker");
+        if (dockerFlagProvided) {
+            flagConfig.docker = options.docker;
+        }
+        // Validate: websocket package only makes sense with websocket template
+        if (flagConfig.websocket_package && flagConfig.template === "rest_api") {
+            console.error("❌ Error: --ws flag can only be used with websocket+rest_api template");
+            process.exit(1);
+        }
+        // PostgreSQL_Prisma + JavaScript warning
+        if (flagConfig.database === "postgresql_prisma"
+            && flagConfig.language === "js") {
+            console.warn("⚠️  Warning: JavaScript does not work properly with PostgreSQL (Prisma). Consider using TypeScript.");
+        }
+        const answer = await inquirer.prompt([
+            {
+                type: "input",
+                name: "name",
+                message: "Project Name",
+                default: generateRandomNames(),
+            },
+        ]);
+        let project_path = getSafeProjectPath(answer.name);
+        // console.log(project_path);
+        // Only prompt for template if not provided via flags
+        const templateSelection = flagConfig.template
+            ? { template: flagConfig.template }
+            : await inquirer.prompt([
+                {
+                    type: "select",
+                    name: "template",
+                    message: "Template",
+                    choices: [
+                        {
+                            name: "REST API [Express, CORS, dotenv, JWT, Helmet, Pino]",
+                            value: "rest_api",
+                        },
+                        {
+                            name: "WebSockets + REST API [Express, CORS, dotenv, JWT, ws or socket.io]",
+                            value: "websocket+rest_api",
+                        },
+                    ],
+                    default: 0,
+                },
+            ]);
+        await checkEnv();
+        const config = await inquirer.prompt([
+            {
+                type: "select",
+                name: "websocket_package",
+                message: "WebSocket Engine",
+                choices: [
+                    {
+                        name: "Socket.io (Room support, auto-reconnect, broadcast helpers)",
+                        value: "socket.io",
+                    },
+                    {
+                        name: "ws (Lightweight, manual control)",
+                        value: "ws",
+                    },
+                ],
+                default: 0,
+                when: () => !flagConfig.websocket_package
+                    && templateSelection.template === "websocket+rest_api",
+            },
+            {
+                type: "select",
+                name: "language",
+                message: "Language",
+                choices: [
+                    {
+                        name: "Javascript",
+                        value: "js",
+                    },
+                    {
+                        name: "Typescript",
+                        value: "ts",
+                    },
+                ],
+                when: () => !flagConfig.language,
+            },
+            {
+                type: "select",
+                name: "database",
+                message: (answers) => (flagConfig.language || answers.language) === "js"
+                    ? "Database (Warning: JavaScript does not work properly with PostgreSQL (Prisma). Use TypeScript.)"
+                    : "Database",
+                choices: [
+                    { name: "None", value: "none" },
+                    { name: "MongoDB (Mongoose)", value: "mongo" },
+                    {
+                        name: "PostgreSQL (Prisma)",
+                        value: "postgresql_prisma",
+                    },
+                ],
+                default: 0,
+                when: () => !flagConfig.database,
+            },
+            {
+                type: "confirm",
+                name: "docker",
+                message: "Would you like to generate a Dockerfile for this project?",
+                default: false,
+                when: () => flagConfig.docker === undefined,
+            },
+            {
+                type: "select",
+                name: "packageManager",
+                message: "Package Manager",
+                choices: [
+                    {
+                        name: "npm (default)",
+                        value: "npm",
+                    },
+                    {
+                        name: "pnpm",
+                        value: "pnpm",
+                    },
+                    {
+                        name: "yarn",
+                        value: "yarn",
+                    },
+                ],
+                default: 0,
+                when: () => !options.pm,
+            },
+        ]);
+        const fullConfig = {
+            ...templateSelection,
+            ...flagConfig,
+            ...config,
+        };
+        if (fullConfig.docker && !(await isToolInstalled("docker"))) {
+            console.warn('Warning: "docker" is not installed. Dockerfile will be generated, but you cannot build/run containers until Docker is installed.');
+        }
+        await setup_restApi_project({
+            db: fullConfig.database,
+            path: project_path,
+            name: answer.name,
+            language: fullConfig.language,
+            template: fullConfig.template,
+            websocket_package: fullConfig.websocket_package,
+            Dockerfile: fullConfig.docker,
+            skipGit: options.git === false,
+            packageManager: options.pm || fullConfig.packageManager || "npm",
+        });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === "ExitPromptError") {
+                console.log("\n⚠️ Process Cancelled by user");
+                process.exit(0);
+            }
+            // Handle other errors
+            console.error("❌ Error:", error.message);
+            process.exit(1);
+        }
+    }
+});
+program.parse();

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/utils..js

@@ -0,0 +1,84 @@
+import { uniqueNamesGenerator, adjectives, colors, } from "unique-names-generator";
+const techTerms = [
+    "forge",
+    "vortex",
+    "backend",
+    "api",
+    "server",
+    "core",
+    "nexus",
+    "stack",
+    "engine",
+    "base",
+    "node",
+    "shuttle",
+];
+import path from "node:path";
+import fse from "fs-extra";
+import chalk from "chalk";
+export function generateRandomNames() {
+    const config = {
+        dictionaries: [adjectives, colors, techTerms], // Combine all three
+        separator: "-", // 'swift-red-forge'
+        length: 2, // Use 3 words for uniqueness
+    };
+    return uniqueNamesGenerator(config);
+}
+export async function updatePackageJson(projectPath, language) {
+    // logic here...
+    const packagePath = path.join(projectPath, "package.json");
+    try {
+        const pkg = await fse.readJson(packagePath);
+        const scripts = language === "js"
+            ? {
+                dev: "nodemon index.js",
+            }
+            : {
+                dev: "nodemon --exec ts-node src/index.ts",
+            };
+        const orderedPkg = {
+            ...pkg, // start from existing package.json
+            name: pkg.name,
+            version: pkg.version,
+            description: "Generated by Stack Forge",
+            main: "index.js",
+            type: "module",
+            scripts: { ...pkg.scripts, ...scripts },
+        };
+        await fse.writeJson(packagePath, orderedPkg, { spaces: 2 });
+        // console.log("Package.json updated successfully!");
+        return true;
+    }
+    catch (error) {
+        console.log("Error in updating the package.json file", error);
+        return false;
+    }
+}
+export function showSuccessfulMessage(project_config) {
+    console.log(chalk.bold.green(`\n🎉 Successfully forged "${project_config.name}"!\n`));
+    console.log(chalk.white("Next steps:"));
+    console.log(chalk.cyan(`  cd ${project_config.name}`));
+    console.log(chalk.cyan(`  npm install`)); // Just in case they skipped auto-install
+    console.log(chalk.cyan(`  npm run dev\n`));
+    console.log(chalk.gray("Happy coding! 🚀"));
+}
+export async function updateTsconfig(file_path) {
+    try {
+        const tsconfigPath = path.join(file_path, "tsconfig.json");
+        const config = await fse.readJson(tsconfigPath);
+        config.compilerOptions = {
+            ...config.compilerOptions,
+            rootDir: "./src",
+            outDir: "./dist",
+            sourceMap: false,
+            declaration: false,
+            declarationMap: false,
+            // Ensure other output-related things are false as requested
+        };
+        await fse.writeJSON(tsconfigPath, config, { spaces: 2 });
+    }
+    catch (error) {
+        console.log("Error in updating the tsconfig.json file", error);
+        return false;
+    }
+}

package/dist/utils/utils.js

@@ -0,0 +1,156 @@
+import { uniqueNamesGenerator, adjectives, colors, } from "unique-names-generator";
+const techTerms = [
+    "forge",
+    "vortex",
+    "backend",
+    "api",
+    "server",
+    "core",
+    "nexus",
+    "stack",
+    "engine",
+    "base",
+    "node",
+    "shuttle",
+];
+import path from "node:path";
+import fse from "fs-extra";
+import chalk from "chalk";
+import { execa } from "execa";
+export function generateRandomNames() {
+    const config = {
+        dictionaries: [adjectives, colors, techTerms], // Combine all three
+        separator: "-",
+        length: 2,
+    };
+    return uniqueNamesGenerator(config);
+}
+export async function updatePackageJson(projectPath, language) {
+    // logic here...
+    const packagePath = path.join(projectPath, "package.json");
+    try {
+        const pkg = await fse.readJson(packagePath);
+        const scripts = language === "js"
+            ? {
+                dev: "nodemon index.js",
+            }
+            : {
+                dev: "nodemon --exec ts-node src/index.ts",
+                build: "tsc -b",
+            };
+        const orderedPkg = {
+            ...pkg, // starting from existing package.json
+            name: pkg.name,
+            version: pkg.version,
+            description: "Generated by Stack Forge",
+            main: "index.js",
+            ...(language === "js" ? { type: "module" } : {}),
+            scripts: { ...pkg.scripts, ...scripts },
+        };
+        await fse.writeJson(packagePath, orderedPkg, { spaces: 2 });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Error updating package.json: ${message}`);
+    }
+}
+export function showSuccessfulMessage(project_config) {
+    console.log(chalk.bold.green(`\n🎉 Successfully forged "${project_config.name}"!\n`));
+    console.log(chalk.white("Next steps:"));
+    console.log(chalk.cyan(`  cd ${project_config.name}`));
+    console.log(chalk.cyan(`  npm run dev\n`));
+    console.log(chalk.gray("Happy coding! 🚀"));
+}
+export async function updateTsconfig(file_path) {
+    try {
+        const tsconfigPath = path.join(file_path, "tsconfig.json");
+        const config = {
+            compilerOptions: {
+                target: "ES2022",
+                module: "CommonJs",
+                moduleResolution: "Node",
+                lib: ["ES2022"],
+                rootDir: "./src",
+                outDir: "./dist",
+                baseUrl: ".",
+                esModuleInterop: true,
+                forceConsistentCasingInFileNames: true,
+                resolveJsonModule: true,
+                isolatedModules: true,
+                strict: true,
+                skipLibCheck: true,
+                noImplicitAny: true,
+                sourceMap: false,
+                declaration: false,
+                declarationMap: false,
+                removeComments: true,
+            },
+            include: ["src/**/*"],
+            exclude: ["node_modules", "dist"],
+        };
+        await fse.writeJSON(tsconfigPath, config, { spaces: 2 });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Error updating tsconfig.json: ${message}`);
+    }
+}
+export function validateProjectName(name) {
+    if (!name || name.trim() === "")
+        throw new Error("Project name cannot be empty");
+    if (name.includes(".."))
+        throw new Error("Project name cannot contain '..'");
+    if (/[\/\\]/.test(name))
+        throw new Error("Project name cannot contain path separators");
+    if (!/^[a-zA-Z0-9._-]+$/.test(name))
+        throw new Error("Invalid characters in project name");
+    if (name.length > 40) {
+        throw new Error("Name Should be less than 50 Characters");
+    }
+    if (name.length <= 3) {
+        // console.log(name);
+        throw new Error("Name should contain more than 3 characters");
+    }
+}
+export function getSafeProjectPath(name) {
+    validateProjectName(name);
+    const base = process.cwd();
+    const resolved = path.resolve(base, name);
+    // console.log(resolved);
+    if (!resolved.startsWith(base + path.sep)) {
+        throw new Error("Path traversal attempt blocked");
+    }
+    return resolved;
+}
+export async function checkEnv() {
+    const requiredTools = ["npm", "npx"];
+    for (const tool of requiredTools) {
+        try {
+            await execa(tool, ["--version"]);
+        }
+        catch (error) {
+            throw new Error(`Required tool "${tool}" is not installed or not in your PATH.`);
+        }
+    }
+    if (!(await isToolInstalled("git"))) {
+        console.warn(chalk.yellow('Warning: "git" is not installed. Project setup will continue without git initialization.'));
+    }
+}
+export async function isToolInstalled(tool) {
+    try {
+        await execa(tool, ["--version"]);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export async function removeProjectDirectory(projectPath) {
+    try {
+        await fse.remove(projectPath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to remove project directory "${projectPath}": ${message}`);
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@dhruvinjs/appinit",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "appinit": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "cors": "^2.8.6",
+    "ejs": "^4.0.1",
+    "execa": "^9.6.1",
+    "express": "^5.2.1",
+    "fs-extra": "^11.3.3",
+    "helmet": "^8.1.0",
+    "inquirer": "^13.2.2",
+    "jsonwebtoken": "^9.0.3",
+    "ora": "^9.1.0",
+    "unique-names-generator": "^4.7.1",
+    "appinit-templates": "1.0.1"
+  },
+  "author": "dhruvinjs",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/ejs": "^3.1.5",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.15.3",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "npx tsc -b",
+    "dev": "tsc -b && node dist/index.js"
+  }
+}