initkit 1.1.0

package/bin/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+/**
+ * Entry point for the CLI application
+ * This file should be kept minimal - it just delegates to the main CLI logic
+ */
+
+import '../src/cli.js';

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "initkit",
+  "version": "1.1.0",
+  "type": "module",
+  "description": "A modern CLI tool for scaffolding production-ready web projects with live npm version fetching, multiple frameworks, and best practices built-in",
+  "main": "src/index.js",
+  "bin": {
+    "initkit": "./bin/index.js"
+  },
+  "scripts": {
+    "start": "node bin/index.js",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test:watch": "npm test -- --watch",
+    "test:coverage": "npm test -- --coverage",
+    "test:unit": "npm test -- __tests__/unit",
+    "test:integration": "npm test -- __tests__/integration",
+    "lint": "eslint src/**/*.js",
+    "format": "prettier --write \"src/**/*.js\"",
+    "prepublishOnly": "npm test && npm run lint"
+  },
+  "keywords": [
+    "cli",
+    "scaffold",
+    "generator",
+    "project-initializer",
+    "boilerplate",
+    "template",
+    "starter",
+    "web-development",
+    "react",
+    "nextjs",
+    "vue",
+    "express",
+    "typescript",
+    "fullstack",
+    "monorepo",
+    "vite",
+    "tailwind",
+    "redux-toolkit",
+    "prisma",
+    "docker",
+    "turborepo"
+  ],
+  "author": "Shirish Shrestha <shirishshrestha07@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shirishshrestha/initkit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/shirishshrestha/initkit/issues"
+  },
+  "homepage": "https://github.com/shirishshrestha/initkit#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "inquirer": "^9.2.15",
+    "ora": "^8.0.1",
+    "fs-extra": "^11.2.0",
+    "ejs": "^3.1.9",
+    "validate-npm-package-name": "^5.0.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.56.0",
+    "prettier": "^3.2.4",
+    "jest": "^29.7.0",
+    "@types/node": "^20.11.5"
+  }
+}

package/src/cli.js

@@ -0,0 +1,264 @@
+import { program } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { createProject } from './commands/create.js';
+import { getQuestions } from './prompts/questions.js';
+import { createRequire } from 'module';
+import {
+  displayError,
+  CLIError,
+  ERROR_CODES,
+  setupGracefulShutdown,
+} from './utils/errorHandler.js';
+import { validateProjectName, checkDirectoryExists } from './utils/validation.js';
+
+const require = createRequire(import.meta.url);
+const packageJson = require('../package.json');
+
+// Display banner
+function displayBanner() {
+  console.log('');
+  console.log(chalk.cyan('╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('║') + chalk.cyan.bold('                                                            ') + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.cyan.bold('               Welcome to InitKit CLI!                      ') + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.cyan.bold('                                                            ') + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.white('       Scaffold modern web projects with best               ') + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.white('       practices and lightning-fast speed ⚡                ') + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.cyan.bold('                                                            ') + chalk.cyan('║'));
+  console.log(chalk.cyan('╚════════════════════════════════════════════════════════════╝'));
+  console.log('');
+  console.log(chalk.gray(`         Version ${packageJson.version} | Made with ❤️  by developers\n`));
+}
+
+// Set up the CLI program
+
+program
+  .name('initkit')
+  .description(packageJson.description)
+  .usage('[command] [options]')
+  .version(packageJson.version, '-v, --version', 'Output the current version')
+  .addHelpText('after', `
+Examples:
+  $ initkit                          # Interactive mode with step-by-step prompts
+  $ initkit my-app                   # Create project with interactive prompts
+  $ initkit my-app --yes             # Use defaults, skip all prompts
+  $ initkit my-app --ts --no-git     # TypeScript without Git initialization
+
+Documentation:
+  Quick Start:  https://github.com/shirishshrestha/initkit/blob/main/docs/QUICK_START.md
+  User Guide:   https://github.com/shirishshrestha/initkit/blob/main/docs/user-guide.md
+  GitHub:       https://github.com/shirishshrestha/initkit
+
+Need help? Report issues at: https://github.com/shirishshrestha/initkit/issues
+  `);
+
+// Main create command
+program
+  .command('create [project-name]', { isDefault: true })
+  .description('Create a new project with interactive prompts')
+  .option('-t, --template <template>', 'Specify template (react, vue, express, etc.)')
+  .option('-y, --yes', 'Skip prompts and use sensible defaults')
+  .option('--ts, --typescript', 'Use TypeScript (recommended)')
+  .option('--js, --javascript', 'Use JavaScript instead of TypeScript')
+  .option('--no-git', 'Skip Git repository initialization')
+  .option('--no-install', 'Skip automatic dependency installation')
+  .option('-p, --package-manager <manager>', 'Package manager (npm, yarn, pnpm)', 'npm')
+  .option('--verbose', 'Show detailed output and logs')
+  .addHelpText('after', `
+Examples:
+  $ initkit create my-react-app
+  $ initkit create api-server --template express --typescript
+  $ initkit create quick-app --yes --package-manager yarn
+  
+The create command guides you through an interactive setup with 13 questions:
+  1. Project name validation
+  2. Project type selection (Frontend/Backend/Full Stack/Library)
+  3. Framework selection (React, Vue, Express, etc.)
+  4. Language preference (TypeScript/JavaScript)
+  5. Folder structure (Feature-based, Type-based, etc.)
+  6. Styling solution (Tailwind, CSS Modules, etc.)
+  7. Additional tools (Docker, CI/CD, Testing)
+  8. Package manager choice
+  9. Git initialization
+  `)
+  .action(async (projectName, options) => {
+    try {
+      displayBanner();
+
+      let answers;
+      let projectPath;
+
+      // Validate project name if provided
+      if (projectName) {
+        const validation = validateProjectName(projectName);
+        if (!validation.valid) {
+          const suggestion = require('../utils/validation.js').suggestProjectName(projectName);
+          throw new CLIError(
+            `"${projectName}" is not a valid project name`,
+            ERROR_CODES.VALIDATION_ERROR,
+            { suggestion: suggestion, issue: validation.errors[0] }
+          );
+        }
+
+        // Check if directory exists
+        const dirCheck = checkDirectoryExists(projectName);
+        if (dirCheck.exists) {
+          throw new CLIError(
+            `A folder named "${projectName}" already exists here`,
+            ERROR_CODES.DIRECTORY_EXISTS,
+            { path: dirCheck.path, projectName }
+          );
+        }
+
+        projectPath = dirCheck.path;
+      }
+
+      if (options.yes) {
+        // Use default configuration
+        answers = {
+          projectName: projectName || 'my-project',
+          projectType: 'fullstack',
+          frontend: 'react',
+          backend: 'express',
+          language: options.javascript ? 'javascript' : 'typescript',
+          folderStructure: 'feature-based',
+          typescriptStrict: 'strict',
+          useGit: options.git !== false,
+          installDependencies: options.install !== false,
+          packageManager: options.packageManager || 'npm',
+          features: ['eslint', 'prettier', 'dotenv'],
+          additionalLibraries: [],
+        };
+      } else {
+        // Interactive prompts
+        console.log(chalk.cyan('Let\'s set up your project!\n'));
+        const questions = getQuestions(projectName);
+        answers = await inquirer.prompt(questions);
+        
+        // Set additional options from CLI flags
+        if (options.javascript) {
+          answers.language = 'javascript';
+        }
+        answers.useGit = options.git !== false;
+        answers.installDependencies = options.install !== false;
+        answers.packageManager = options.packageManager || answers.packageManager;
+      }
+
+      // Derive projectPath if not set
+      if (!projectPath) {
+        projectPath = checkDirectoryExists(answers.projectName).path;
+      }
+
+      // Setup graceful shutdown handler
+      setupGracefulShutdown(projectPath);
+
+      // Create the project
+      console.log(chalk.cyan('\nCreating your project...\n'));
+      await createProject(answers, {
+        verbose: options.verbose,
+        projectPath,
+      });
+
+      // Success message is now part of the comprehensive summary in create.js
+
+    } catch (error) {
+      displayError(error, { projectName });
+      process.exit(1);
+    }
+  });
+
+// Info command
+program
+  .command('info')
+  .description('Display detailed information about InitKit CLI')
+  .action(() => {
+    console.log(chalk.cyan.bold('\n╔════════════════════════════════════════════════╗'));
+    console.log(chalk.cyan.bold('║          InitKit CLI Information              ║'));
+    console.log(chalk.cyan.bold('╚════════════════════════════════════════════════╝\n'));
+    
+    console.log(chalk.white.bold('Version:     ') + chalk.green(packageJson.version));
+    console.log(chalk.white.bold('Description: ') + chalk.gray(packageJson.description));
+    console.log(chalk.white.bold('Author:      ') + chalk.gray(packageJson.author));
+    console.log(chalk.white.bold('License:     ') + chalk.gray(packageJson.license));
+    console.log(chalk.white.bold('Repository:  ') + chalk.blue(packageJson.repository?.url || 'N/A'));
+    
+    console.log(chalk.yellow.bold('\nSupported Frameworks:'));
+    console.log(chalk.gray('  Frontend: ') + 'React, Vue, Next.js, Angular, Svelte, Nuxt');
+    console.log(chalk.gray('  Backend:  ') + 'Express, NestJS, Fastify, Koa, Hapi');
+    console.log(chalk.gray('  Database: ') + 'PostgreSQL, MongoDB, MySQL, SQLite');
+    
+    console.log(chalk.yellow.bold('\nFeatures:'));
+    console.log(chalk.gray('  ✓ Interactive project scaffolding'));
+    console.log(chalk.gray('  ✓ TypeScript & JavaScript support'));
+    console.log(chalk.gray('  ✓ Full-stack monorepo with Turborepo'));
+    console.log(chalk.gray('  ✓ Docker & Docker Compose'));
+    console.log(chalk.gray('  ✓ CI/CD with GitHub Actions'));
+    console.log(chalk.gray('  ✓ ESLint, Prettier, Husky'));
+    console.log(chalk.gray('  ✓ Automatic rollback on errors'));
+    
+    console.log(chalk.cyan('\n💡 Get started: ') + chalk.white('initkit --help\n'));
+  });
+
+// List command - show available templates
+program
+  .command('list')
+  .description('List all available project templates, frameworks, and tools')
+  .action(() => {
+    console.log(chalk.cyan.bold('\n╔════════════════════════════════════════════════╗'));
+    console.log(chalk.cyan.bold('║        Available Templates & Tools            ║'));
+    console.log(chalk.cyan.bold('╚════════════════════════════════════════════════╝\n'));
+    
+    console.log(chalk.yellow.bold('🎨 Frontend Frameworks:'));
+    console.log(chalk.gray('  • React          ') + chalk.dim('- Popular library for building UIs'));
+    console.log(chalk.gray('  • Vue.js         ') + chalk.dim('- Progressive JavaScript framework'));
+    console.log(chalk.gray('  • Next.js        ') + chalk.dim('- React framework with SSR & SSG'));
+    console.log(chalk.gray('  • Angular        ') + chalk.dim('- Platform for building applications'));
+    console.log(chalk.gray('  • Svelte         ') + chalk.dim('- Compile-time framework'));
+    console.log(chalk.gray('  • Nuxt.js        ') + chalk.dim('- Vue.js framework with SSR'));
+    
+    console.log(chalk.yellow.bold('\n⚙️  Backend Frameworks:'));
+    console.log(chalk.gray('  • Express.js     ') + chalk.dim('- Fast, minimalist web framework'));
+    console.log(chalk.gray('  • NestJS         ') + chalk.dim('- Progressive Node.js framework'));
+    console.log(chalk.gray('  • Fastify        ') + chalk.dim('- Fast and low overhead'));
+    console.log(chalk.gray('  • Koa            ') + chalk.dim('- Next generation web framework'));
+    console.log(chalk.gray('  • Hapi           ') + chalk.dim('- Rich framework for building applications'));
+    
+    console.log(chalk.yellow.bold('\n💾 Databases:'));
+    console.log(chalk.gray('  • PostgreSQL     ') + chalk.dim('- Advanced relational database'));
+    console.log(chalk.gray('  • MongoDB        ') + chalk.dim('- NoSQL document database'));
+    console.log(chalk.gray('  • MySQL          ') + chalk.dim('- Popular relational database'));
+    console.log(chalk.gray('  • SQLite         ') + chalk.dim('- Lightweight embedded database'));
+    
+    console.log(chalk.yellow.bold('\n🎨 Styling Solutions:'));
+    console.log(chalk.gray('  • Tailwind CSS   ') + chalk.dim('- Utility-first CSS framework'));
+    console.log(chalk.gray('  • CSS Modules    ') + chalk.dim('- Locally scoped CSS'));
+    console.log(chalk.gray('  • Styled Comp.   ') + chalk.dim('- CSS-in-JS solution'));
+    console.log(chalk.gray('  • Sass/SCSS      ') + chalk.dim('- CSS preprocessor'));
+    console.log(chalk.gray('  • Emotion        ') + chalk.dim('- Performant CSS-in-JS'));
+    
+    console.log(chalk.yellow.bold('\n🛠️  Development Tools:'));
+    console.log(chalk.gray('  • Docker         ') + chalk.dim('- Containerization'));
+    console.log(chalk.gray('  • GitHub Actions ') + chalk.dim('- CI/CD automation'));
+    console.log(chalk.gray('  • ESLint         ') + chalk.dim('- Code linting'));
+    console.log(chalk.gray('  • Prettier       ') + chalk.dim('- Code formatting'));
+    console.log(chalk.gray('  • Jest/Vitest    ') + chalk.dim('- Testing frameworks'));
+    console.log(chalk.gray('  • Turborepo      ') + chalk.dim('- Monorepo build system'));
+    
+    console.log(chalk.cyan('\n💡 Create a project: ') + chalk.white('initkit [project-name]\n'));
+  });
+
+// Handle unknown commands
+program.on('command:*', () => {
+  console.error(chalk.red('\nInvalid command: %s'), program.args.join(' '));
+  console.log(chalk.yellow('See --help for a list of available commands.\n'));
+  process.exit(1);
+});
+
+// Show help if no arguments provided
+if (!process.argv.slice(2).length) {
+  displayBanner();
+  program.outputHelp();
+}
+
+// Parse command-line arguments
+program.parse();

package/src/commands/create.js

@@ -0,0 +1,264 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { generateTemplate } from '../utils/templateGenerator.js';
+import { installDependencies } from '../utils/packageManager.js';
+import { initGit } from '../utils/git.js';
+import {
+  CLIError,
+  ERROR_CODES,
+  withErrorHandling,
+  rollbackProject,
+  safeFileOperation,
+} from '../utils/errorHandler.js';
+
+/**
+ * Create a new project based on user configuration
+ * 
+ * This is the main orchestration function that:
+ * 1. Creates the project directory
+ * 2. Generates template files
+ * 3. Installs dependencies
+ * 4. Initializes Git repository
+ * 5. Handles errors with automatic rollback
+ * 
+ * @param {Object} answers - User's configuration from interactive prompts
+ * @param {string} answers.projectName - Name of the project (used for directory)
+ * @param {string} answers.projectType - Type of project ('frontend'|'backend'|'fullstack'|'library')
+ * @param {string} [answers.frontend] - Frontend framework choice
+ * @param {string} [answers.backend] - Backend framework choice
+ * @param {string} answers.language - Programming language ('typescript'|'javascript')
+ * @param {string} answers.packageManager - Package manager ('npm'|'yarn'|'pnpm')
+ * @param {boolean} [answers.gitInit] - Whether to initialize Git repository
+ * 
+ * @param {Object} [options={}] - Additional command-line options
+ * @param {boolean} [options.verbose=false] - Show detailed output during creation
+ * @param {string} [options.projectPath] - Custom path for project (overrides answers.projectName)
+ * 
+ * @returns {Promise<void>}
+ * @throws {CLIError} If project creation fails at any step (automatic rollback triggered)
+ * 
+ * @example
+ * // Basic usage
+ * await createProject({
+ *   projectName: 'my-app',
+ *   projectType: 'frontend',
+ *   frontend: 'react',
+ *   language: 'typescript',
+ *   packageManager: 'npm',
+ *   gitInit: true
+ * });
+ * 
+ * @example
+ * // With verbose output
+ * await createProject(answers, { verbose: true });
+ */
+async function createProject(answers, options = {}) {
+  const { verbose = false, projectPath: customProjectPath } = options;
+  const projectPath = customProjectPath || path.join(process.cwd(), answers.projectName);
+  let spinner;
+
+  try {
+    // Step 1: Check if directory already exists
+    if (await fs.pathExists(projectPath)) {
+      throw new CLIError(
+        `Directory "${answers.projectName}" already exists!`,
+        ERROR_CODES.DIRECTORY_EXISTS,
+        { path: projectPath }
+      );
+    }
+
+    // Step 2: Create project directory
+    spinner = ora({
+      text: 'Creating project structure...',
+      color: 'cyan',
+    }).start();
+
+    await safeFileOperation(
+      () => fs.ensureDir(projectPath),
+      'Creating project directory'
+    );
+
+    if (verbose) {
+      spinner.info(chalk.gray(`Created directory: ${projectPath}`));
+      spinner.start('Generating project files...');
+    }
+
+    // Step 3: Generate project files from templates
+    await withErrorHandling(
+      () => generateTemplate(projectPath, answers),
+      {
+        projectPath,
+        rollback: true,
+        errorCode: ERROR_CODES.CREATION_FAILED,
+        context: { step: 'template generation' },
+      }
+    );
+
+    spinner.succeed(chalk.green('Project structure created'));
+
+    // Step 4: Initialize Git if requested
+    if (answers.useGit) {
+      const gitSpinner = ora('Initializing Git repository...').start();
+      
+      try {
+        await initGit(projectPath);
+        gitSpinner.succeed(chalk.green('Git repository initialized'));
+      } catch (error) {
+        gitSpinner.warn(chalk.yellow('Git initialization skipped'));
+        
+        if (verbose) {
+          console.log(chalk.gray(`   Reason: ${error.message}`));
+        }
+      }
+    }
+
+    // Step 5: Install dependencies
+    if (answers.installDependencies !== false) {
+      try {
+        await installDependencies(projectPath, answers.packageManager, {
+          verbose,
+        });
+      } catch (error) {
+        // Don't fail the entire process if install fails
+        console.log(chalk.yellow('\nDependency installation failed'));
+        console.log(chalk.gray('   You can install them manually later\n'));
+        
+        if (verbose) {
+          console.log(chalk.gray(`   Error: ${error.message}`));
+        }
+      }
+    } else {
+      console.log(chalk.gray('\n   Skipping dependency installation (--no-install)'));
+    }
+
+    // Step 6: Display comprehensive success summary
+    displaySuccessSummary(answers, projectPath, verbose);
+
+  } catch (error) {
+    // Stop any running spinners
+    if (spinner && spinner.isSpinning) {
+      spinner.fail(chalk.red('Project creation failed'));
+    }
+
+    // If it's already a CLIError, just re-throw it
+    if (error instanceof CLIError) {
+      throw error;
+    }
+
+    // Wrap unexpected errors
+    throw new CLIError(
+      `Failed to create project: ${error.message}`,
+      ERROR_CODES.CREATION_FAILED,
+      { originalError: error.name, path: projectPath }
+    );
+  }
+}
+
+/**
+ * Display comprehensive success summary after project creation
+ * @param {Object} answers - Project configuration
+ * @param {string} projectPath - Path to the project
+ * @param {boolean} verbose - Show detailed information
+ */
+function displaySuccessSummary(answers, projectPath, verbose = false) {
+  console.log('');
+  console.log(chalk.green('╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.green('║') + chalk.green.bold('              ✨ Project Created Successfully! ✨           ') + chalk.green('║'));
+  console.log(chalk.green('╚════════════════════════════════════════════════════════════╝'));
+  console.log('');
+
+  // Project info section
+  console.log(chalk.cyan.bold('  📦 Project Information'));
+  console.log(chalk.white(`     ${chalk.gray('Name:')}        ${chalk.bold(answers.projectName)}`));
+  console.log(chalk.white(`     ${chalk.gray('Type:')}        ${answers.projectType}`));
+  console.log(chalk.white(`     ${chalk.gray('Language:')}    ${answers.language || 'JavaScript'}`));
+  
+  if (answers.frontend) {
+    console.log(chalk.white(`     ${chalk.gray('Frontend:')}    ${answers.frontend}`));
+  }
+  
+  if (answers.backend) {
+    console.log(chalk.white(`     ${chalk.gray('Backend:')}     ${answers.backend}`));
+  }
+
+  if (answers.fullstackType) {
+    console.log(chalk.white(`     ${chalk.gray('Architecture:')} ${answers.fullstackType}`));
+  }
+  
+  if (answers.database && answers.database !== 'none') {
+    console.log(chalk.white(`     ${chalk.gray('Database:')}    ${answers.database}`));
+  }
+  console.log('');
+
+  // Location section
+  console.log(chalk.cyan.bold('  📁 Project Location'));
+  console.log(chalk.white(`     ${projectPath}`));
+  console.log('');
+
+  // Features section
+  if (answers.features && answers.features.length > 0) {
+    console.log(chalk.cyan.bold('  ⚙️  Configured Features'));
+    answers.features.forEach(feature => {
+      console.log(chalk.white(`     ${chalk.green('✓')} ${feature}`));
+    });
+    console.log('');
+  }
+
+  // Additional libraries
+  if (answers.additionalLibraries && answers.additionalLibraries.length > 0) {
+    console.log(chalk.cyan.bold('  📚 Additional Libraries'));
+    answers.additionalLibraries.slice(0, 5).forEach(lib => {
+      console.log(chalk.white(`     ${chalk.green('✓')} ${lib}`));
+    });
+    if (answers.additionalLibraries.length > 5) {
+      console.log(chalk.gray(`     ... and ${answers.additionalLibraries.length - 5} more`));
+    }
+    console.log('');
+  }
+
+  // Package manager info
+  const packagesInstalled = answers.installDependencies !== false;
+  if (packagesInstalled) {
+    console.log(chalk.cyan.bold('  📦 Dependencies'));
+    console.log(chalk.white(`     ${chalk.green('✓')} Installed with ${answers.packageManager}`));
+    console.log('');
+  }
+
+  // Next steps
+  console.log(chalk.cyan.bold('  🚀 Next Steps'));
+  console.log('');
+  console.log(chalk.white(`     ${chalk.yellow('1.')} Navigate to your project:`));
+  console.log(chalk.gray(`        cd ${answers.projectName}`));
+  console.log('');
+  
+  if (!packagesInstalled) {
+    console.log(chalk.white(`     ${chalk.yellow('2.')} Install dependencies:`));
+    console.log(chalk.gray(`        ${answers.packageManager} install`));
+    console.log('');
+  }
+  
+  const stepNum = packagesInstalled ? 2 : 3;
+  console.log(chalk.white(`     ${chalk.yellow(stepNum + '.')} Start development server:`));
+  console.log(chalk.gray(`        ${answers.packageManager} ${answers.packageManager === 'npm' ? 'run ' : ''}dev`));
+  console.log('');
+  
+  console.log(chalk.white(`     ${chalk.yellow((stepNum + 1) + '.')} Read the README for more info:`));
+  console.log(chalk.gray(`        cat README.md`));
+  console.log('');
+
+  // Documentation link
+  console.log(chalk.cyan.bold('  📚 Documentation'));
+  console.log(chalk.white(`     Check out the README.md in your project folder`));
+  console.log(chalk.white(`     for setup instructions and best practices.`));
+  console.log('');
+
+  // Footer
+  console.log(chalk.green('  ─────────────────────────────────────────────────────────────'));
+  console.log(chalk.green.bold('           🎉 Happy coding! Your project is ready! 🎉'));
+  console.log(chalk.green('  ─────────────────────────────────────────────────────────────'));
+  console.log('');
+}
+
+export { createProject };

package/src/index.js

@@ -0,0 +1,9 @@
+/**
+ * Main entry point for programmatic usage
+ * This allows the package to be used as a library, not just a CLI
+ */
+
+import { createProject } from './commands/create.js';
+import { getQuestions } from './prompts/questions.js';
+
+export { createProject, getQuestions };