create-gramstax 0.0.1

package/dist/src/create-OLD.js

@@ -0,0 +1,676 @@
+import * as fs from "fs";
+import * as path from "path";
+import { log } from "./utils/logger";
+import { spawn } from "child_process";
+import enquirer from "enquirer";
+/**
+ * Recursively copy directory structure
+ */
+function copyDirectorySync(source, destination, variables = {}) {
+    // Create destination directory if it doesn't exist
+    if (!fs.existsSync(destination)) {
+        fs.mkdirSync(destination, { recursive: true });
+    }
+    // Read all items in source directory
+    const items = fs.readdirSync(source, { withFileTypes: true });
+    for (const item of items) {
+        const sourcePath = path.join(source, item.name);
+        const destPath = path.join(destination, item.name);
+        if (item.isDirectory()) {
+            // Recursively copy subdirectories
+            copyDirectorySync(sourcePath, destPath, variables);
+        }
+        else if (item.isFile()) {
+            // Copy file and replace variables if needed
+            let content = fs.readFileSync(sourcePath, `utf-8`);
+            // Replace template variables in content
+            content = replaceTemplateVariables(content, variables);
+            fs.writeFileSync(destPath, content);
+        }
+    }
+}
+/**
+ * Replace template variables in content
+ */
+function replaceTemplateVariables(content, variables) {
+    let result = content;
+    for (const [key, value] of Object.entries(variables)) {
+        result = result.replace(new RegExp(`{{${key}}}`, `g`), value);
+    }
+    return result;
+}
+/**
+ * Get package manager commands
+ */
+function getPackageManagerCommands(packageManager) {
+    const commands = {
+        bun: {
+            install: `bun install`,
+            dev: `bun dev`,
+            start: `bun start`,
+            "pm2:start": `bun run pm2:start`,
+            "pm2:stop": `bun run pm2:stop`,
+            "pm2:restart": `bun run pm2:restart`,
+            "pm2:delete": `bun run pm2:delete`,
+            "pm2:logs": `bun run pm2:logs`,
+            "pm2:monit": `bun run pm2:monit`
+        },
+        npm: {
+            install: `npm install`,
+            dev: `npm run dev`,
+            start: `npm start`,
+            "pm2:start": `npm run pm2:start`,
+            "pm2:stop": `npm run pm2:stop`,
+            "pm2:restart": `npm run pm2:restart`,
+            "pm2:delete": `npm run pm2:delete`,
+            "pm2:logs": `npm run pm2:logs`,
+            "pm2:monit": `npm run pm2:monit`
+        },
+        pnpm: {
+            install: `pnpm install`,
+            dev: `pnpm dev`,
+            start: `pnpm start`,
+            "pm2:start": `pnpm pm2:start`,
+            "pm2:stop": `pnpm pm2:stop`,
+            "pm2:restart": `pnpm pm2:restart`,
+            "pm2:delete": `pnpm pm2:delete`,
+            "pm2:logs": `pnpm pm2:logs`,
+            "pm2:monit": `pnpm pm2:monit`
+        },
+        yarn: {
+            install: `yarn install`,
+            dev: `yarn dev`,
+            start: `yarn start`,
+            "pm2:start": `yarn pm2:start`,
+            "pm2:stop": `yarn pm2:stop`,
+            "pm2:restart": `yarn pm2:restart`,
+            "pm2:delete": `yarn pm2:delete`,
+            "pm2:logs": `yarn pm2:logs`,
+            "pm2:monit": `yarn pm2:monit`
+        }
+    };
+    return commands[packageManager];
+}
+export async function createProject(projectDirectory, options) {
+    // Display ASCII art banner
+    printBanner();
+    // Get project name - if not provided, prompt or use current directory
+    let projectName = projectDirectory;
+    let projectPath;
+    if (!projectName) {
+        if (options?.yes) {
+            // Use current directory name like npm init
+            projectName = path.basename(process.cwd());
+            projectPath = process.cwd();
+            // Check if current directory is empty
+            const files = fs.readdirSync(projectPath);
+            if (files.length > 0) {
+                log.error(`Current directory is not empty!`);
+                process.exit(1);
+            }
+        }
+        else {
+            projectName = await promptForProjectName();
+            projectPath = path.resolve(process.cwd(), projectName);
+            // Check if directory already exists
+            if (fs.existsSync(projectPath) && projectName != ``) {
+                log.error(`Directory "${projectName}" already exists!`);
+                process.exit(1);
+            }
+            if (projectName != ``) {
+                // Create project directory
+                fs.mkdirSync(projectPath, { recursive: true });
+            }
+        }
+    }
+    else {
+        projectPath = path.resolve(process.cwd(), projectName);
+        // Check if directory already exists
+        if (fs.existsSync(projectPath)) {
+            log.error(`Directory "${projectName}" already exists!`);
+            process.exit(1);
+        }
+        // Create project directory
+        fs.mkdirSync(projectPath, { recursive: true });
+    }
+    log.info(`Creating project: ${path.basename(projectPath)}`);
+    log.info(`Location: ${projectPath}`);
+    // Prompt for configuration if not in --yes mode
+    let packageManager;
+    let runtime;
+    let setupEslint;
+    if (options?.yes) {
+        packageManager = detectPackageManager(options);
+        runtime = packageManager === `bun` ? `bun` : `node`;
+        setupEslint = false;
+        log.info(`Using defaults - Package Manager: ${packageManager}, Runtime: ${runtime}, ESLint: No`);
+    }
+    else {
+        const config = await promptForConfiguration(options);
+        packageManager = config.packageManager;
+        runtime = config.runtime;
+        setupEslint = config.eslint;
+        log.info(`Configuration - Package Manager: ${packageManager}, Runtime: ${runtime}, ESLint: ${setupEslint ? `Yes` : `No`}`);
+    }
+    // Generate project structure
+    log.info(`Generating project structure...`);
+    await generateProjectStructure(projectPath, projectName, packageManager, runtime);
+    // Setup ESLint if requested
+    if (setupEslint) {
+        log.info(`Setting up ESLint...`);
+        await setupEslintConfig(projectPath, packageManager);
+    }
+    const commands = getPackageManagerCommands(packageManager);
+    log.success(`Project created successfully!`);
+    log.info(``);
+    log.info(`Next steps:`);
+    if (projectDirectory) {
+        log.info(`  cd ${projectName}`);
+    }
+    log.info(`  ${commands.install}`);
+    log.info(`  ${commands.dev}`);
+    log.info(``);
+    log.info(`For production:`);
+    log.info(`  ${commands[`pm2:start`]}`);
+}
+function printBanner() {
+    const banner = `
+ $$$$$$\\                                               $$\\                         
+$$  __$$\\                                              $$ |                        
+$$ /  \\__| $$$$$$\\  $$$$$$\\  $$$$$$\\$$$$\\   $$$$$$$\\ $$$$$$\\    $$$$$$\\  $$\\   $$\\ 
+$$ |$$$$\\ $$  __$$\\ \\____$$\\ $$  _$$  _$$\\ $$  _____|\\_$$  _|   \\____$$\\ \\$$\\ $$  |
+$$ |\\_$$ |$$ |  \\__|$$$$$$$ |$$ / $$ / $$ |\\$$$$$$\\    $$ |     $$$$$$$ | \\$$$$  / 
+$$ |  $$ |$$ |     $$  __$$ |$$ | $$ | $$ | \\____$$\\   $$ |$$\\ $$  __$$ | $$  $$<  
+\\$$$$$$  |$$ |     \\$$$$$$$ |$$ | $$ | $$ |$$$$$$$  |  \\$$$$  |\\$$$$$$$ |$$  /\\$$\\ 
+ \\______/ \\__|      \\_______|\\__| \\__| \\__|\\_______/    \\____/  \\_______|\\__/  \\__|
+                                                                                                                                            
+`;
+    console.log(banner);
+}
+async function promptForProjectName() {
+    const response = await enquirer.prompt({
+        type: `input`,
+        name: `projectName`,
+        message: `What is your project named?`,
+        initial: ``,
+        validate: (value) => {
+            if (value == ``) {
+                return true;
+            }
+            if (!/^[a-z0-9-_]+$/i.test(value)) {
+                return `Project name can only contain letters, numbers, hyphens, and underscores`;
+            }
+            return true;
+        }
+    });
+    return response.projectName;
+}
+async function promptForConfiguration(options) {
+    const questions = [];
+    // Package manager selection
+    if (!options?.useBun && !options?.useNpm && !options?.usePnpm && !options?.useYarn) {
+        questions.push({
+            type: `select`,
+            name: `packageManager`,
+            message: `Which package manager would you like to use?`,
+            choices: [
+                { name: `bun`, message: `Bun (recommended)`, value: `bun` },
+                { name: `npm`, message: `npm`, value: `npm` },
+                { name: `pnpm`, message: `pnpm`, value: `pnpm` },
+                { name: `yarn`, message: `Yarn`, value: `yarn` }
+            ],
+            initial: 0
+        });
+    }
+    // Runtime selection
+    questions.push({
+        type: `select`,
+        name: `runtime`,
+        message: `Which runtime would you like to use?`,
+        choices: [
+            { name: `bun`, message: `Bun (recommended)`, value: `bun` },
+            { name: `node`, message: `Node.js`, value: `node` }
+        ],
+        initial: 0
+    });
+    // ESLint
+    if (options?.eslint === undefined) {
+        questions.push({
+            type: `confirm`,
+            name: `eslint`,
+            message: `Would you like to use ESLint?`,
+            initial: true
+        });
+    }
+    const answers = await enquirer.prompt(questions);
+    return {
+        packageManager: answers.packageManager || detectPackageManager(options),
+        runtime: answers.runtime,
+        eslint: answers.eslint !== undefined ? answers.eslint : options?.eslint || false
+    };
+}
+function detectPackageManager(options) {
+    if (options?.useBun)
+        return `bun`;
+    if (options?.useNpm)
+        return `npm`;
+    if (options?.usePnpm)
+        return `pnpm`;
+    if (options?.useYarn)
+        return `yarn`;
+    // Try to detect from environment
+    const userAgent = process.env.npm_config_user_agent || ``;
+    if (userAgent.includes(`bun`))
+        return `bun`;
+    if (userAgent.includes(`pnpm`))
+        return `pnpm`;
+    if (userAgent.includes(`yarn`))
+        return `yarn`;
+    // Default to bun
+    return `bun`;
+}
+async function generateProjectStructure(projectPath, projectName, packageManager, runtime) {
+    log.info(`📁 Creating project structure...`);
+    const templatesPath = path.join(__dirname, `templates`);
+    const commands = getPackageManagerCommands(packageManager);
+    // Prepare template variables
+    const variables = {
+        projectName,
+        installCmd: commands.install,
+        runDevCmd: commands.dev,
+        runStartCmd: commands.start,
+        runPm2StartCmd: commands[`pm2:start`],
+        runPm2StopCmd: commands[`pm2:stop`],
+        runPm2RestartCmd: commands[`pm2:restart`],
+        runPm2DeleteCmd: commands[`pm2:delete`],
+        runPm2LogsCmd: commands[`pm2:logs`],
+        runPm2MonitCmd: commands[`pm2:monit`]
+    };
+    log.info(`📝 Copying template files...`);
+    // Copy entire template structure recursively
+    copyDirectorySync(templatesPath, projectPath, variables);
+    // Create logs directory
+    fs.mkdirSync(path.join(projectPath, `logs`), { recursive: true });
+    fs.writeFileSync(path.join(projectPath, `logs/.gitkeep`), ``);
+    // Create .env.example as copy of .env
+    const envPath = path.join(projectPath, `.env`);
+    const envExamplePath = path.join(projectPath, `.env.example`);
+    if (fs.existsSync(envPath)) {
+        fs.copyFileSync(envPath, envExamplePath);
+    }
+    // Remove bunfig.toml if runtime is NOT bun
+    if (runtime !== `bun`) {
+        const bunfigPath = path.join(projectPath, `bunfig.toml`);
+        if (fs.existsSync(bunfigPath)) {
+            fs.unlinkSync(bunfigPath);
+        }
+    }
+    log.success(`✅ All files generated!`);
+}
+async function setupEslintConfig(projectPath, packageManager) {
+    log.info(``);
+    log.info(`🔍 Setting up ESLint...`);
+    return new Promise((resolve, reject) => {
+        // Use npm init @eslint/config with --yes flag for default configuration
+        const initProcess = spawn(`npm`, [`init`, `@eslint/config@latest`, `--`, `--yes`], {
+            cwd: projectPath,
+            stdio: `inherit`,
+            shell: true
+        });
+        initProcess.on(`close`, (code) => {
+            if (code === 0) {
+                log.success(`✅ ESLint configured successfully!`);
+                resolve();
+            }
+            else {
+                log.warn(`⚠️  ESLint setup failed. You can set it up later with: npm init @eslint/config`);
+                resolve(); // Don't fail the whole process
+            }
+        });
+        initProcess.on(`error`, (error) => {
+            log.warn(`⚠️  ESLint setup failed: ${error.message}`);
+            log.info(`You can set it up later with: npm init @eslint/config`);
+            resolve(); // Don't fail the whole process
+        });
+    });
+}
+export default class {
+    runtime;
+    projectPath;
+    projectName;
+    packageManager;
+    constructor() {
+        //
+    }
+    printBanner() {
+        const banner = `
+ $$$$$$\\                                               $$\\                         
+$$  __$$\\                                              $$ |                        
+$$ /  \\__| $$$$$$\\  $$$$$$\\  $$$$$$\\$$$$\\   $$$$$$$\\ $$$$$$\\    $$$$$$\\  $$\\   $$\\ 
+$$ |$$$$\\ $$  __$$\\ \\____$$\\ $$  _$$  _$$\\ $$  _____|\\_$$  _|   \\____$$\\ \\$$\\ $$  |
+$$ |\\_$$ |$$ |  \\__|$$$$$$$ |$$ / $$ / $$ |\\$$$$$$\\    $$ |     $$$$$$$ | \\$$$$  / 
+$$ |  $$ |$$ |     $$  __$$ |$$ | $$ | $$ | \\____$$\\   $$ |$$\\ $$  __$$ | $$  $$<  
+\\$$$$$$  |$$ |     \\$$$$$$$ |$$ | $$ | $$ |$$$$$$$  |  \\$$$$  |\\$$$$$$$ |$$  /\\$$\\ 
+ \\______/ \\__|      \\_______|\\__| \\__| \\__|\\_______/    \\____/  \\_______|\\__/  \\__|
+                                                                                                                                            
+`;
+        console.log(banner);
+    }
+    detectPackageManager(options) {
+        if (options?.useBun)
+            return (this.packageManager = `bun`);
+        if (options?.useNpm)
+            return (this.packageManager = `npm`);
+        if (options?.usePnpm)
+            return (this.packageManager = `pnpm`);
+        if (options?.useYarn)
+            return (this.packageManager = `yarn`);
+        // Try to detect from environment
+        const userAgent = process.env.npm_config_user_agent || ``;
+        if (userAgent.includes(`bun`))
+            return (this.packageManager = `bun`);
+        if (userAgent.includes(`pnpm`))
+            return (this.packageManager = `pnpm`);
+        if (userAgent.includes(`yarn`))
+            return (this.packageManager = `yarn`);
+        // Default to bun
+        return (this.packageManager = `bun`);
+    }
+    /**
+     * Recursively copy directory structure
+     */
+    copyDirectorySync(source, destination, variables = {}) {
+        // Create destination directory if it doesn't exist
+        if (!fs.existsSync(destination)) {
+            fs.mkdirSync(destination, { recursive: true });
+        }
+        // Read all items in source directory
+        const items = fs.readdirSync(source, { withFileTypes: true });
+        for (const item of items) {
+            const sourcePath = path.join(source, item.name);
+            const destPath = path.join(destination, item.name);
+            if (item.isDirectory()) {
+                // Recursively copy subdirectories
+                copyDirectorySync(sourcePath, destPath, variables);
+            }
+            else if (item.isFile()) {
+                // Copy file and replace variables if needed
+                let content = fs.readFileSync(sourcePath, `utf-8`);
+                // Replace template variables in content
+                content = replaceTemplateVariables(content, variables);
+                fs.writeFileSync(destPath, content);
+            }
+        }
+    }
+    /**
+     * Replace template variables in content
+     */
+    replaceTemplateVariables(content, variables) {
+        let result = content;
+        for (const [key, value] of Object.entries(variables)) {
+            result = result.replace(new RegExp(`{{${key}}}`, `g`), value);
+        }
+        return result;
+    }
+    /**
+     * Get package manager commands
+     */
+    getPackageManagerCommands(packageManager) {
+        const commands = {
+            bun: {
+                install: `bun install`,
+                dev: `bun dev`,
+                start: `bun start`,
+                "pm2:start": `bun run pm2:start`,
+                "pm2:stop": `bun run pm2:stop`,
+                "pm2:restart": `bun run pm2:restart`,
+                "pm2:delete": `bun run pm2:delete`,
+                "pm2:logs": `bun run pm2:logs`,
+                "pm2:monit": `bun run pm2:monit`
+            },
+            npm: {
+                install: `npm install`,
+                dev: `npm run dev`,
+                start: `npm start`,
+                "pm2:start": `npm run pm2:start`,
+                "pm2:stop": `npm run pm2:stop`,
+                "pm2:restart": `npm run pm2:restart`,
+                "pm2:delete": `npm run pm2:delete`,
+                "pm2:logs": `npm run pm2:logs`,
+                "pm2:monit": `npm run pm2:monit`
+            },
+            pnpm: {
+                install: `pnpm install`,
+                dev: `pnpm dev`,
+                start: `pnpm start`,
+                "pm2:start": `pnpm pm2:start`,
+                "pm2:stop": `pnpm pm2:stop`,
+                "pm2:restart": `pnpm pm2:restart`,
+                "pm2:delete": `pnpm pm2:delete`,
+                "pm2:logs": `pnpm pm2:logs`,
+                "pm2:monit": `pnpm pm2:monit`
+            },
+            yarn: {
+                install: `yarn install`,
+                dev: `yarn dev`,
+                start: `yarn start`,
+                "pm2:start": `yarn pm2:start`,
+                "pm2:stop": `yarn pm2:stop`,
+                "pm2:restart": `yarn pm2:restart`,
+                "pm2:delete": `yarn pm2:delete`,
+                "pm2:logs": `yarn pm2:logs`,
+                "pm2:monit": `yarn pm2:monit`
+            }
+        };
+        return commands[packageManager];
+    }
+    async promptForProjectName() {
+        const response = await enquirer.prompt({
+            type: `input`,
+            name: `projectName`,
+            message: `What is your project named?`,
+            initial: ``,
+            validate: (value) => {
+                if (value == ``) {
+                    return true;
+                }
+                if (!/^[a-z0-9-_]+$/i.test(value)) {
+                    return `Project name can only contain letters, numbers, hyphens, and underscores`;
+                }
+                return true;
+            }
+        });
+        return response.projectName;
+    }
+    async promptForConfiguration(options) {
+        const questions = [];
+        // Package manager selection
+        if (!options?.useBun && !options?.useNpm && !options?.usePnpm && !options?.useYarn) {
+            questions.push({
+                type: `select`,
+                name: `packageManager`,
+                message: `Which package manager would you like to use?`,
+                choices: [
+                    { name: `bun`, message: `Bun (recommended)`, value: `bun` },
+                    { name: `npm`, message: `npm`, value: `npm` },
+                    { name: `pnpm`, message: `pnpm`, value: `pnpm` },
+                    { name: `yarn`, message: `Yarn`, value: `yarn` }
+                ],
+                initial: 0
+            });
+        }
+        // Runtime selection
+        questions.push({
+            type: `select`,
+            name: `runtime`,
+            message: `Which runtime would you like to use?`,
+            choices: [
+                { name: `bun`, message: `Bun (recommended)`, value: `bun` },
+                { name: `node`, message: `Node.js`, value: `node` }
+            ],
+            initial: 0
+        });
+        // ESLint
+        if (options?.eslint === undefined) {
+            questions.push({
+                type: `confirm`,
+                name: `eslint`,
+                message: `Would you like to use ESLint?`,
+                initial: true
+            });
+        }
+        const answers = await enquirer.prompt(questions);
+        return {
+            packageManager: answers.packageManager || detectPackageManager(options),
+            runtime: answers.runtime,
+            eslint: answers.eslint !== undefined ? answers.eslint : options?.eslint || false
+        };
+    }
+    async generateProjectStructure(projectPath, projectName, packageManager, runtime) {
+        log.info(`📁 Creating project structure...`);
+        const templatesPath = path.join(__dirname, `templates`);
+        const commands = getPackageManagerCommands(packageManager);
+        // Prepare template variables
+        const variables = {
+            projectName,
+            installCmd: commands.install,
+            runDevCmd: commands.dev,
+            runStartCmd: commands.start,
+            runPm2StartCmd: commands[`pm2:start`],
+            runPm2StopCmd: commands[`pm2:stop`],
+            runPm2RestartCmd: commands[`pm2:restart`],
+            runPm2DeleteCmd: commands[`pm2:delete`],
+            runPm2LogsCmd: commands[`pm2:logs`],
+            runPm2MonitCmd: commands[`pm2:monit`]
+        };
+        log.info(`📝 Copying template files...`);
+        // Copy entire template structure recursively
+        copyDirectorySync(templatesPath, projectPath, variables);
+        // Create logs directory
+        fs.mkdirSync(path.join(projectPath, `logs`), { recursive: true });
+        fs.writeFileSync(path.join(projectPath, `logs/.gitkeep`), ``);
+        // Create .env.example as copy of .env
+        const envPath = path.join(projectPath, `.env`);
+        const envExamplePath = path.join(projectPath, `.env.example`);
+        if (fs.existsSync(envPath)) {
+            fs.copyFileSync(envPath, envExamplePath);
+        }
+        // Remove bunfig.toml if runtime is NOT bun
+        if (runtime !== `bun`) {
+            const bunfigPath = path.join(projectPath, `bunfig.toml`);
+            if (fs.existsSync(bunfigPath)) {
+                fs.unlinkSync(bunfigPath);
+            }
+        }
+        log.success(`✅ All files generated!`);
+    }
+    async setupEslintConfig(projectPath, packageManager) {
+        log.info(``);
+        log.info(`🔍 Setting up ESLint...`);
+        return new Promise((resolve, reject) => {
+            // Use npm init @eslint/config with --yes flag for default configuration
+            const initProcess = spawn(`npm`, [`init`, `@eslint/config@latest`, `--`, `--yes`], {
+                cwd: projectPath,
+                stdio: `inherit`,
+                shell: true
+            });
+            initProcess.on(`close`, (code) => {
+                if (code === 0) {
+                    log.success(`✅ ESLint configured successfully!`);
+                    resolve();
+                }
+                else {
+                    log.warn(`⚠️  ESLint setup failed. You can set it up later with: npm init @eslint/config`);
+                    resolve(); // Don't fail the whole process
+                }
+            });
+            initProcess.on(`error`, (error) => {
+                log.warn(`⚠️  ESLint setup failed: ${error.message}`);
+                log.info(`You can set it up later with: npm init @eslint/config`);
+                resolve(); // Don't fail the whole process
+            });
+        });
+    }
+    async createProject(projectDirectory, options) {
+        // Display ASCII art banner
+        printBanner();
+        // Get project name - if not provided, prompt or use current directory
+        let projectName = projectDirectory;
+        let projectPath;
+        if (!projectName) {
+            if (options?.yes) {
+                // Use current directory name like npm init
+                projectName = path.basename(process.cwd());
+                projectPath = process.cwd();
+                // Check if current directory is empty
+                const files = fs.readdirSync(projectPath);
+                if (files.length > 0) {
+                    log.error(`Current directory is not empty!`);
+                    process.exit(1);
+                }
+            }
+            else {
+                projectName = await promptForProjectName();
+                projectPath = path.resolve(process.cwd(), projectName);
+                // Check if directory already exists
+                if (fs.existsSync(projectPath) && projectName != ``) {
+                    log.error(`Directory "${projectName}" already exists!`);
+                    process.exit(1);
+                }
+                if (projectName != ``) {
+                    // Create project directory
+                    fs.mkdirSync(projectPath, { recursive: true });
+                }
+            }
+        }
+        else {
+            projectPath = path.resolve(process.cwd(), projectName);
+            // Check if directory already exists
+            if (fs.existsSync(projectPath)) {
+                log.error(`Directory "${projectName}" already exists!`);
+                process.exit(1);
+            }
+            // Create project directory
+            fs.mkdirSync(projectPath, { recursive: true });
+        }
+        log.info(`Creating project: ${path.basename(projectPath)}`);
+        log.info(`Location: ${projectPath}`);
+        // Prompt for configuration if not in --yes mode
+        let packageManager;
+        let runtime;
+        let setupEslint;
+        if (options?.yes) {
+            packageManager = this.detectPackageManager(options);
+            runtime = packageManager === `bun` ? `bun` : `node`;
+            setupEslint = false;
+            log.info(`Using defaults - Package Manager: ${packageManager}, Runtime: ${runtime}, ESLint: No`);
+        }
+        else {
+            const config = await promptForConfiguration(options);
+            packageManager = config.packageManager;
+            runtime = config.runtime;
+            setupEslint = config.eslint;
+            log.info(`Configuration - Package Manager: ${packageManager}, Runtime: ${runtime}, ESLint: ${setupEslint ? `Yes` : `No`}`);
+        }
+        // Generate project structure
+        log.info(`Generating project structure...`);
+        await generateProjectStructure(projectPath, projectName, packageManager, runtime);
+        // Setup ESLint if requested
+        if (setupEslint) {
+            log.info(`Setting up ESLint...`);
+            await setupEslintConfig(projectPath, packageManager);
+        }
+        const commands = getPackageManagerCommands(packageManager);
+        log.success(`Project created successfully!`);
+        log.info(``);
+        log.info(`Next steps:`);
+        if (projectDirectory) {
+            log.info(`  cd ${projectName}`);
+        }
+        log.info(`  ${commands.install}`);
+        log.info(`  ${commands.dev}`);
+        log.info(``);
+        log.info(`For production:`);
+        log.info(`  ${commands[`pm2:start`]}`);
+    }
+}