@mvp-kit/create 0.0.10 → 0.0.12

package/dist/create.js

@@ -1,629 +1,921 @@
 import fs from 'fs-extra';
-import path from 'path';
-import { execSync } from 'child_process';
+import path from 'node:path';
+import { glob } from 'glob';
 import chalk from 'chalk';
 import ora from 'ora';
-import inquirer from 'inquirer';
-import { glob } from 'glob';
-// Enhanced Box System
-const BOX_WIDTH = 72;
-const BOX_INDENT = '    ';
-function drawBox(content, title) {
-    const lines = [];
-    // Top border
-    lines.push(BOX_INDENT + '┌' + '─'.repeat(BOX_WIDTH - 2) + '┐');
-    // Title if provided
-    if (title) {
-        lines.push(drawBoxLine(title, true));
-        lines.push(drawBoxLine(''));
-    }
-    // Content lines with wrapping
-    content.forEach(line => {
-        const wrappedLines = wrapText(line, BOX_WIDTH - 4);
-        wrappedLines.forEach(wrappedLine => {
-            lines.push(drawBoxLine(wrappedLine));
-        });
-    });
-    // Add empty line if we have content
-    if (content.length > 0) {
-        lines.push(drawBoxLine(''));
+import { execSync } from 'node:child_process';
+import prompts from 'prompts';
+import { processTemplate, shouldSkipFile, getTargetFilePath } from './template.js';
+import { downloadTemplate } from './download.js';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+const SUPPORTED_TEMPLATES = ['core', 'saas'];
+function validateTemplateName(template) {
+    if (!SUPPORTED_TEMPLATES.includes(template)) {
+        throw new Error(`Unsupported template "${template}". Supported templates: ${SUPPORTED_TEMPLATES.join(', ')}`);
     }
-    // Bottom border
-    lines.push(BOX_INDENT + '└' + '─'.repeat(BOX_WIDTH - 2) + '┘');
-    return lines.join('\n');
 }
-function wrapText(text, maxWidth) {
-    if (text.length <= maxWidth) {
-        return [text];
-    }
-    const words = text.split(' ');
-    const lines = [];
-    let currentLine = '';
-    for (const word of words) {
-        if ((currentLine + (currentLine ? ' ' : '') + word).length <= maxWidth) {
-            currentLine += (currentLine ? ' ' : '') + word;
+/**
+ * Get path to template directory
+ * Supports multiple ways to specify template location:
+ * 1. --template-path CLI option (passed via options.templatePath)
+ * 2. MVPKIT_TEMPLATE_PATH environment variable
+ * 3. Download from GitHub releases using --template option
+ */
+async function getTemplatePath(options = {}) {
+    // 1. CLI option takes highest priority
+    if (options.templatePath) {
+        const templatePath = path.resolve(options.templatePath);
+        if (fs.existsSync(templatePath)) {
+            return templatePath;
         }
-        else {
-            if (currentLine)
-                lines.push(currentLine);
-            currentLine = word;
+        throw new Error(`Template path not found: ${templatePath}`);
+    }
+    // 2. Environment variable
+    if (process.env.MVPKIT_TEMPLATE_PATH) {
+        const templatePath = path.resolve(process.env.MVPKIT_TEMPLATE_PATH);
+        if (fs.existsSync(templatePath)) {
+            return templatePath;
         }
+        throw new Error(`Template path from MVPKIT_TEMPLATE_PATH not found: ${templatePath}`);
     }
-    if (currentLine)
-        lines.push(currentLine);
-    return lines;
-}
-function drawBoxLine(content, isTitle = false) {
-    const availableWidth = BOX_WIDTH - 4; // Account for borders and spaces
-    const padding = availableWidth - content.length;
-    const coloredText = isTitle ? chalk.bold.cyan(content) : chalk.white(content);
-    return BOX_INDENT + '│ ' + coloredText + ' '.repeat(padding) + ' │';
-}
-import { generateTemplateVariables, getCoreRepositoryPath, shouldSkipFile, DEFAULT_SKIP_PATTERNS, transformFileName } from './utils.js';
-import { getFileTransformFunction, transformTemplateFileName } from './template.js';
-import { setupDatabase } from './database.js';
-import { TemplateDownloader, TEMPLATE_REGISTRY } from './template-downloader.js';
-function detectPackageManager(dir) {
-    // Check how CLI was invoked (highest priority)
-    const invocation = detectInvocationMethod();
-    if (invocation) {
-        return invocation;
-    }
-    // Check for lock files in priority order
-    if (fs.existsSync(path.join(dir, 'bun.lockb'))) {
-        return { pm: 'bun', version: getPackageVersion('bun') };
-    }
-    if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))) {
-        return { pm: 'pnpm', version: getPackageVersion('pnpm') };
-    }
-    // Default to pnpm
-    return { pm: 'pnpm', version: '10.14.0' };
+    // 3. Local monorepo fallback for core/saas templates (dev workflow)
+    const template = options.template || 'core';
+    if (SUPPORTED_TEMPLATES.includes(template)) {
+        const cliDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+        const monorepoTemplatePath = path.resolve(cliDir, '..', template);
+        if (fs.existsSync(monorepoTemplatePath)) {
+            return monorepoTemplatePath;
+        }
+    }
+    // 4. Download from GitHub based on template option
+    const cacheDir = path.join(os.tmpdir(), 'mvpkit-template-cache');
+    const templateDir = path.join(cacheDir, template);
+    // Check if caching is disabled or if we don't have a cached template
+    const useCache = options.cache !== false;
+    const hasCachedTemplate = useCache && fs.existsSync(templateDir) && fs.readdirSync(templateDir).length > 0;
+    if (hasCachedTemplate) {
+        return templateDir;
+    }
+    // Download the template (this will clear the directory if it exists)
+    return await downloadTemplate(template, templateDir);
 }
-function getPackageVersion(pm) {
+/**
+ * Read template configuration from template.json
+ */
+async function readTemplateConfig(templateDir) {
     try {
-        const result = execSync(`${pm} --version`, { encoding: 'utf8', stdio: 'pipe' });
-        return result.trim();
+        const configPath = path.join(templateDir, 'template.json');
+        if (fs.existsSync(configPath)) {
+            const configContent = await fs.readFile(configPath, 'utf-8');
+            return JSON.parse(configContent);
+        }
     }
-    catch {
-        return '10.14.0';
+    catch (error) {
+        console.log(chalk.yellow('⚠️  Could not read template configuration'));
     }
-}
-function detectInvocationMethod() {
-    // Check process.execArgv and process.argv to see how we were invoked
-    const execPath = process.execPath;
-    const argv = process.argv;
-    const userAgent = process.env.npm_config_user_agent || '';
-    // Check if invoked via bunx
-    if (execPath.includes('bun') || userAgent.startsWith('bun')) {
-        return { pm: 'bun', version: extractVersion(userAgent) || 'latest' };
-    }
-    // Check argv for package manager indicators
-    const commandLine = argv.join(' ');
-    if (commandLine.includes('bunx') || commandLine.includes('bun run')) {
-        return { pm: 'bun', version: extractVersion(userAgent) || 'latest' };
-    }
-    if (commandLine.includes('pnpm') || commandLine.includes('pnpx')) {
-        return { pm: 'pnpm', version: extractVersion(userAgent) || '10.14.0' };
-    }
-    if (commandLine.includes('npx') || commandLine.includes('npm create')) {
-        return { pm: 'pnpm', version: '10.14.0' };
-    }
-    // Check user agent string
-    if (userAgent.startsWith('pnpm'))
-        return { pm: 'pnpm', version: extractVersion(userAgent) || '10.14.0' };
-    if (userAgent.startsWith('bun'))
-        return { pm: 'bun', version: extractVersion(userAgent) || 'latest' };
-    if (userAgent.startsWith('npm'))
-        return { pm: 'pnpm', version: '10.14.0' };
     return null;
 }
-function extractVersion(userAgent) {
-    // Extract version from user agent string
-    // Examples: "npm/8.19.2 node/v18.17.0 linux x64", "pnpm/8.6.0", "bun/1.0.0"
-    const match = userAgent.match(/^(npm|pnpm|bun)\/([^\s]+)/);
-    return match ? match[2] : '10.14.0';
-}
-function getPackageManagerCommand(pmInfo) {
-    const commands = {
-        npm: 'npm',
-        pnpm: 'pnpm',
-        bun: 'bun'
-    };
-    return commands[pmInfo.pm];
-}
-export async function createProject(projectName, options = {}) {
-    const targetDir = path.resolve(projectName);
-    // Show MVPKit branding
-    console.log();
-    const logoWidth = BOX_WIDTH - 2; // Account for box borders and padding
-    const logoIndent = '    ';
-    console.log(chalk.cyan.bold(logoIndent + '╔' + '═'.repeat(logoWidth) + '╗'));
-    console.log(chalk.cyan.bold(logoIndent + '║') + chalk.bold.white(' '.repeat(Math.floor((logoWidth - 6) / 2)) + 'MVPKit' + ' '.repeat(Math.ceil((logoWidth - 6) / 2))) + chalk.cyan.bold('║'));
-    console.log(chalk.cyan.bold(logoIndent + '║') + chalk.gray(' '.repeat(Math.floor((logoWidth - 35) / 2)) + 'Cloudflare-native React Starter Kit' + ' '.repeat(Math.ceil((logoWidth - 35) / 2))) + chalk.cyan.bold('║'));
-    console.log(chalk.cyan.bold(logoIndent + '╚' + '═'.repeat(logoWidth) + '╝'));
-    console.log();
-    console.log(chalk.blue.bold('                    🚀 Ship production apps in minutes [DEV]'));
-    console.log();
-    // Validate project name and directory
-    if (fs.existsSync(targetDir)) {
-        throw new Error(`Directory ${projectName} already exists`);
-    }
-    // Always use core template (only template available)
-    const templateName = 'core';
-    const template = TEMPLATE_REGISTRY[templateName];
-    if (!template) {
-        throw new Error(`Core template not found`);
-    }
-    // Detect package manager (we need this early for setup files)
-    const packageManagerInfo = detectPackageManager(process.cwd());
-    const pmCommand = getPackageManagerCommand(packageManagerInfo);
-    // Show template info
-    console.log(drawBox([
-        `🆓 ${template.displayName}`,
-        template.description,
-        `Features: ${template.features.slice(0, 2).join(' • ')}`
-    ], 'Template Selected'));
-    console.log();
-    // Generate template variables
-    let variables = generateTemplateVariables(projectName, options, packageManagerInfo.pm, packageManagerInfo.version);
-    // Interactive mode for project customization (default unless explicitly disabled)
-    if (options.interactive !== false) {
-        const { updatedVariables, updatedOptions } = await runInteractivePrompts(projectName, variables, options);
-        variables = updatedVariables;
-        Object.assign(options, updatedOptions);
+/**
+ * Collect missing template variables interactively
+ */
+async function collectVariables(variables, options) {
+    // If non-interactive mode, use simple detection without prompts
+    if (options.interactive === false) {
+        const { packageManager, version: packageManagerVersion } = await detectPackageManager();
+        return {
+            ...variables,
+            packageManager,
+            packageManagerVersion,
+            componentPack: options.componentPack || 'basic',
+            git: options.git !== false
+        };
     }
-    else {
-        // Set opinionated defaults for non-interactive mode
-        options.install = true; // Always install dependencies
-        options.git = options.git !== false; // Create git repo unless explicitly disabled
-        options.setupDb = true; // Always setup database locally
-        options.setupShadcn = true; // Setup shadcn by default
-    }
-    // Project creation message
-    console.log(drawBox([
-        `🎯 Project: ${variables.projectDisplayName}`,
-        `📁 Location: ${targetDir}`,
-        `📋 Template: ${template.displayName}`,
-        '',
-        '🚀 Steps: Download → Install → Setup → Finalize'
-    ], 'Creating Your Project'));
-    // Step 1: Download and copy template
-    const downloader = new TemplateDownloader();
-    const templatePath = await downloader.downloadTemplate(templateName, undefined, options.dev);
-    const copySpinner = ora('Copying template files...').start();
+    const normalizeHandle = (handle) => {
+        if (!handle)
+            return undefined;
+        const trimmed = handle.trim();
+        if (!trimmed)
+            return undefined;
+        return trimmed.startsWith('@') ? trimmed : `@${trimmed}`;
+    };
+    const toSocialUrl = (platform, handle) => {
+        const normalized = normalizeHandle(handle);
+        if (!normalized)
+            return undefined;
+        const username = normalized.slice(1);
+        if (!username)
+            return undefined;
+        if (platform === 'tiktok')
+            return `https://tiktok.com/@${username}`;
+        if (platform === 'x')
+            return `https://x.com/${username}`;
+        if (platform === 'instagram')
+            return `https://instagram.com/${username}`;
+        return `https://github.com/${username}`;
+    };
+    const fieldsToCollect = [
+        // 1. Template selection (if not passed via CLI)
+        {
+            name: 'template',
+            message: 'Select template',
+            type: !options.template && !options.templatePath ? 'select' : null,
+            choices: [
+                { title: 'Core', value: 'core' },
+                { title: 'SaaS', value: 'saas' }
+            ],
+            initial: 0
+        },
+        // 2. Project description
+        {
+            name: 'description',
+            message: 'Project description',
+            type: 'text',
+            initial: options.description || `A full-stack application built with MVPKit`
+        },
+        // 3. Domain name
+        {
+            name: 'domain',
+            message: 'Website domain (for deployment)',
+            type: 'text',
+            initial: options.domain || `${variables.name}.localhost`
+        },
+        // 4. Tagline
+        {
+            name: 'tagline',
+            message: 'Tagline',
+            type: 'text',
+            initial: variables.tagline || 'Build and deploy MVPs faster.'
+        },
+        // 5. Component pack selection
+        {
+            name: 'componentPack',
+            message: 'Choose component pack',
+            type: !options.componentPack ? 'select' : null,
+            choices: [
+                { title: 'Essentials', value: 'basic' },
+                { title: 'All', value: 'all' }
+            ],
+            initial: 0
+        },
+        // 6. SaaS social handles
+        {
+            name: 'socialGithubHandle',
+            message: 'GitHub handle (@username)',
+            type: (_prev, values) => (options.template || values.template || variables.template) === 'saas' ? 'text' : null,
+            initial: variables.social?.github?.handle || '@mvp-kit'
+        },
+        {
+            name: 'socialXHandle',
+            message: 'X handle (@username)',
+            type: (_prev, values) => (options.template || values.template || variables.template) === 'saas' ? 'text' : null,
+            initial: variables.social?.x?.handle || '@mvpkithq'
+        },
+        {
+            name: 'socialInstagramHandle',
+            message: 'Instagram handle (@username)',
+            type: (_prev, values) => (options.template || values.template || variables.template) === 'saas' ? 'text' : null,
+            initial: variables.social?.instagram?.handle || '@mvpkit'
+        },
+        {
+            name: 'socialTiktokHandle',
+            message: 'TikTok handle (@username)',
+            type: (_prev, values) => (options.template || values.template || variables.template) === 'saas' ? 'text' : null,
+            initial: variables.social?.tiktok?.handle || '@mvpkittok'
+        },
+        // 7. Git initialization
+        {
+            name: 'git',
+            message: 'Initialize git repository?',
+            type: options.git === undefined ? 'confirm' : null,
+            initial: options.git !== false,
+        },
+        // 8. Package manager (last, after user sees what will be installed)
+        {
+            name: 'packageManager',
+            message: 'Choose package manager',
+            type: 'select',
+            choices: [
+                { title: 'pnpm [stable]', value: 'pnpm' },
+                { title: 'bun', value: 'bun' }
+            ],
+            initial: 0
+        }
+    ];
     try {
-        await copyAndTransformTemplate(targetDir, variables, templatePath, packageManagerInfo);
-        copySpinner.succeed('Template files copied and transformed');
+        // Check if we can use prompts (TTY available)
+        if (!process.stdin.isTTY) {
+            console.log(chalk.yellow('⚠️  Non-interactive environment detected, using defaults'));
+            const { packageManager, version: packageManagerVersion } = await detectPackageManager();
+            return {
+                ...variables,
+                packageManager,
+                packageManagerVersion
+            };
+        }
+        console.log(chalk.cyan('🔧 Project Configuration'));
+        console.log(chalk.white.dim('═'.repeat(50)));
+        let responses;
+        try {
+            responses = await prompts(fieldsToCollect, {
+                onCancel: () => {
+                    console.log(chalk.yellow('\n⚠️  Operation cancelled by user'));
+                    process.exit(1);
+                }
+            });
+        }
+        catch (promptError) {
+            console.log(chalk.yellow('⚠️  Interactive prompts failed, using defaults'));
+            console.log(chalk.white.dim(`   Error: ${promptError instanceof Error ? promptError.message : 'Unknown error'}`));
+            const { packageManager, version: packageManagerVersion } = await detectPackageManager();
+            return {
+                ...variables,
+                packageManager,
+                packageManagerVersion
+            };
+        }
+        // Get package manager version
+        let packageManagerVersion = '9.0.0'; // default
+        if (responses.packageManager === 'bun') {
+            try {
+                packageManagerVersion = execSync('bun --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
+            }
+            catch {
+                packageManagerVersion = '1.0.0';
+            }
+        }
+        else {
+            try {
+                packageManagerVersion = execSync('pnpm --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
+            }
+            catch {
+                packageManagerVersion = '9.0.0';
+            }
+        }
+        const socialGithubHandle = normalizeHandle(responses.socialGithubHandle || variables.social?.github?.handle);
+        const socialXHandle = normalizeHandle(responses.socialXHandle || variables.social?.x?.handle);
+        const socialInstagramHandle = normalizeHandle(responses.socialInstagramHandle || variables.social?.instagram?.handle);
+        const socialTiktokHandle = normalizeHandle(responses.socialTiktokHandle || variables.social?.tiktok?.handle);
+        return {
+            ...variables,
+            template: responses.template || options.template || variables.template,
+            description: responses.description || variables.description,
+            domain: responses.domain || variables.domain,
+            tagline: responses.tagline || variables.tagline,
+            social: {
+                github: {
+                    handle: socialGithubHandle,
+                    url: toSocialUrl('github', socialGithubHandle),
+                },
+                x: {
+                    handle: socialXHandle,
+                    url: toSocialUrl('x', socialXHandle),
+                },
+                instagram: {
+                    handle: socialInstagramHandle,
+                    url: toSocialUrl('instagram', socialInstagramHandle),
+                },
+                tiktok: {
+                    handle: socialTiktokHandle,
+                    url: toSocialUrl('tiktok', socialTiktokHandle),
+                },
+            },
+            packageManager: responses.packageManager || 'pnpm',
+            packageManagerVersion,
+            componentPack: responses.componentPack || options.componentPack,
+            git: responses.git !== undefined ? responses.git : (options.git !== false)
+        };
     }
     catch (error) {
-        copySpinner.fail('Failed to copy template files');
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(chalk.red('Error details:'), errorMessage);
-        throw new Error(`Template copy failed: ${errorMessage}`);
-    }
-    // Update package manager for target directory
-    const targetPackageManagerInfo = detectPackageManager(targetDir);
-    const targetPmCommand = getPackageManagerCommand(targetPackageManagerInfo);
-    // Step 2: Install dependencies (always install unless explicitly disabled)
+        console.log(chalk.yellow('\n⚠️  Prompt collection failed, using defaults'));
+        const { packageManager, version: packageManagerVersion } = await detectPackageManager();
+        return {
+            ...variables,
+            packageManager,
+            packageManagerVersion
+        };
+    }
+}
+/**
+ * Complete project setup after template is copied
+ * Runs the same steps for both CLI and TUI modes
+ */
+async function completeProjectSetup(targetDir, variables, options) {
+    const packageManager = variables.packageManager;
+    // Step 1: Copy package manager specific files
+    await copyPackageManagerFiles(targetDir, variables, options);
+    // Step 2: Install dependencies
     if (options.install !== false) {
-        const installSpinner = ora('Installing dependencies...').start();
-        try {
-            execSync(`${targetPmCommand} install`, { cwd: targetDir, stdio: 'ignore' });
-            installSpinner.succeed('Dependencies installed');
+        await installDependencies(targetDir, packageManager);
+    }
+    // Step 3: Setup database
+    const apiPath = path.join(targetDir, 'services', 'api');
+    if (fs.existsSync(apiPath) && options.install !== false) {
+        await setupDatabase(apiPath, packageManager);
+    }
+    // Step 4: Initialize shadcn in UI package
+    const uiPath = path.join(targetDir, 'packages', 'ui');
+    const hasPreconfiguredUI = fs.existsSync(path.join(uiPath, 'components.json')) &&
+        fs.existsSync(path.join(uiPath, 'src', 'components', 'ui'));
+    if (fs.existsSync(uiPath)) {
+        if (!hasPreconfiguredUI) {
+            await initShadcnInUIPackage(uiPath, 'new-york', options.interactive !== false);
         }
-        catch (error) {
-            installSpinner.fail('Failed to install dependencies');
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.log(chalk.yellow(`💡 You can install them manually with: ${targetPmCommand} install`));
-            console.log(chalk.gray(`   Error: ${errorMessage}`));
+    }
+    // Step 5: Install component pack
+    const componentPack = variables.componentPack;
+    if (componentPack && fs.existsSync(uiPath)) {
+        // The core template already includes the baseline "basic" set.
+        const shouldInstallPack = componentPack === 'all' || !hasPreconfiguredUI;
+        if (shouldInstallPack) {
+            const templateConfig = await readTemplateConfig(targetDir);
+            await installComponentPack(uiPath, componentPack, options.interactive !== false, templateConfig);
         }
     }
-    // Step 3: Setup database
-    let dbSetupCompleted = false;
-    if (options.setupDb !== false) {
-        dbSetupCompleted = await setupDatabase(targetDir, variables);
+    // Step 6: Cleanup tasks
+    await cleanup(targetDir, packageManager);
+    // Step 7: Initialize git at the end
+    const shouldInitGit = variables.git;
+    if (shouldInitGit !== false) {
+        await initializeGitWithCommit(targetDir);
     }
-    // Step 4: Setup shadcn/ui
-    await setupShadcn(targetDir, targetPackageManagerInfo.pm, options);
-    // Step 5: Finalize project
-    if (options.install !== false) {
-        const finalizeSpinner = ora('Finalizing...').start();
-        // Build project
+}
+async function cleanup(targetDir, packageManager) {
+    // Only inherit theme name from UI to web
+    const uiPath = path.join(targetDir, 'packages', 'ui');
+    const webPath = path.join(targetDir, 'apps', 'web');
+    if (fs.existsSync(uiPath) && fs.existsSync(webPath)) {
+        await inheritUIConfigToWeb(uiPath, webPath);
+    }
+    // Run lint fix
+    await runLintFixCommand(targetDir, packageManager);
+}
+/**
+ * Detect package manager based on how CLI was invoked
+ * - npx: Ask user to choose
+ * - pnpm create/pnpm dlx: Use pnpm
+ * - bunx: Use bun
+ */
+async function detectPackageManager() {
+    // Check how the CLI was invoked using environment variables and process.argv
+    const userAgent = process.env.npm_config_user_agent || '';
+    const invocation = process.argv.join(' ');
+    // Check user agent for package manager detection
+    if (userAgent.includes('bun/')) {
         try {
-            execSync(`${targetPmCommand} build`, { cwd: targetDir, stdio: 'ignore' });
+            const bunVersion = execSync('bun --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
+            return { packageManager: 'bun', version: bunVersion };
         }
-        catch (error) {
-            finalizeSpinner.fail('Build failed');
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.log(chalk.red(`💡 Build failed: ${errorMessage}`));
-            console.log(chalk.yellow('   Check the error messages above and fix any issues'));
-            throw new Error(`Build failed: ${errorMessage}`);
+        catch {
+            console.log(chalk.yellow('⚠️  Bun not available, falling back to pnpm'));
+            const pnpmVersion = await getPnpmVersion();
+            return { packageManager: 'pnpm', version: pnpmVersion };
         }
-        // Format and lint code
+    }
+    if (userAgent.includes('pnpm/')) {
+        const pnpmVersion = await getPnpmVersion();
+        return { packageManager: 'pnpm', version: pnpmVersion };
+    }
+    // Check argv for direct invocations (fallback)
+    if (invocation.includes('bunx') || invocation.includes('bun create')) {
         try {
-            execSync(`${targetPmCommand} format:fix`, { cwd: targetDir, stdio: 'ignore' });
-            execSync(`${targetPmCommand} lint:fix`, { cwd: targetDir, stdio: 'ignore' });
+            const bunVersion = execSync('bun --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
+            return { packageManager: 'bun', version: bunVersion };
         }
-        catch (error) {
-            finalizeSpinner.warn('Code formatting/linting skipped (optional)');
+        catch {
+            console.log(chalk.yellow('⚠️  Bun not available, falling back to pnpm'));
+            const pnpmVersion = await getPnpmVersion();
+            return { packageManager: 'pnpm', version: pnpmVersion };
         }
-        // Initialize git (if requested)
-        if (options.git) {
-            try {
-                execSync('git init', { cwd: targetDir, stdio: 'ignore' });
-                execSync('git add .', { cwd: targetDir, stdio: 'ignore' });
-                execSync('git commit -m "Initial commit from MVPKit"', { cwd: targetDir, stdio: 'ignore' });
-            }
-            catch (error) {
-                finalizeSpinner.warn('Git initialization failed (optional)');
-            }
-        }
-        finalizeSpinner.succeed('Setup completed');
-    }
-    // Success message
-    console.log();
-    console.log(drawBox([
-        `🎉 ${variables.projectDisplayName} is ready!`,
-        '',
-        '🎨 Your Cloudflare-native MVP awaits!',
-        '⚡ Powered by MVPKit'
-    ], 'Project Complete!'));
-    console.log();
-    printNextSteps(projectName, options, dbSetupCompleted, targetPackageManagerInfo.pm);
+    }
+    if (invocation.includes('pnpm create') || invocation.includes('pnpm dlx')) {
+        const pnpmVersion = await getPnpmVersion();
+        return { packageManager: 'pnpm', version: pnpmVersion };
+    }
+    // For npx (npm user agent) or unknown, ask user to choose
+    if (userAgent.includes('npm/') || invocation.includes('npx')) {
+        return await promptForPackageManager();
+    }
+    // Fallback: try to detect what's available
+    try {
+        const bunVersion = execSync('bun --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
+        return { packageManager: 'bun', version: bunVersion };
+    }
+    catch {
+        const pnpmVersion = await getPnpmVersion();
+        return { packageManager: 'pnpm', version: pnpmVersion };
+    }
 }
-async function runInteractivePrompts(projectName, variables, options) {
-    console.log();
-    console.log(drawBox([
-        'Just a few quick questions to get you started'
-    ], 'Configure Your Project'));
-    console.log();
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'description',
-            message: `Brief description for "${projectName}":`,
-            default: variables.projectDescription
-        },
-        {
-            type: 'input',
-            name: 'domain',
-            message: 'Production domain name (e.g. myapp.com, leave empty to skip):',
-            default: variables.domainName || ''
-        },
-        {
-            type: 'input',
-            name: 'packageScope',
-            message: 'Package namespace (e.g. @yourcompany):',
-            default: variables.packageScope,
-            validate: (input) => {
-                if (!input.startsWith('@')) {
-                    return 'Must start with @ (e.g. @yourcompany)';
-                }
-                return true;
+/**
+ * Get pnpm version with fallback
+ */
+async function getPnpmVersion() {
+    try {
+        return execSync('pnpm --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
+    }
+    catch {
+        return '9.0.0'; // Default version
+    }
+}
+/**
+ * Prompt user to choose package manager (for npx invocation)
+ */
+async function promptForPackageManager() {
+    const inquirer = await import('inquirer');
+    // Check what's available
+    const bunAvailable = await checkCommandAvailable('bun');
+    const pnpmAvailable = await checkCommandAvailable('pnpm');
+    if (!bunAvailable && !pnpmAvailable) {
+        console.log(chalk.yellow('⚠️  Neither bun nor pnpm found, defaulting to pnpm'));
+        return { packageManager: 'pnpm', version: '9.0.0' };
+    }
+    const choices = [];
+    if (pnpmAvailable)
+        choices.push({ name: 'pnpm (recommended for most projects)', value: 'pnpm' });
+    if (bunAvailable)
+        choices.push({ name: 'bun (fast and modern)', value: 'bun' });
+    const { packageManager } = await inquirer.default.prompt([{
+            type: 'list',
+            name: 'packageManager',
+            message: 'Which package manager would you like to use?',
+            choices,
+            default: 'pnpm'
+        }]);
+    if (packageManager === 'bun') {
+        const bunVersion = execSync('bun --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
+        return { packageManager: 'bun', version: bunVersion };
+    }
+    else {
+        const pnpmVersion = await getPnpmVersion();
+        return { packageManager: 'pnpm', version: pnpmVersion };
+    }
+}
+/**
+ * Check if a command is available
+ */
+async function checkCommandAvailable(command) {
+    try {
+        execSync(`${command} --version`, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create project from template
+ */
+export async function createProject(projectName, options = {}) {
+    const targetDir = path.join(process.cwd(), projectName);
+    const selectedTemplate = options.template || 'core';
+    // Validate target directory
+    if (fs.existsSync(targetDir)) {
+        throw new Error(`Directory ${projectName} already exists`);
+    }
+    if (!options.templatePath && !process.env.MVPKIT_TEMPLATE_PATH) {
+        validateTemplateName(selectedTemplate);
+    }
+    // Build initial template variables
+    const variables = {
+        template: selectedTemplate,
+        name: projectName,
+        description: options.description || `A full-stack application built with MVPKit`,
+        domain: options.domain || `${projectName}.localhost`,
+        executionDate: new Date().toISOString().slice(0, 10),
+        tagline: 'Build and deploy MVPs faster.',
+        social: {
+            github: {
+                handle: '@mvp-kit',
+                url: 'https://github.com/mvp-kit'
+            },
+            x: {
+                handle: '@mvpkithq',
+                url: 'https://x.com/mvpkithq'
+            },
+            instagram: {
+                handle: '@mvpkit',
+                url: 'https://instagram.com/mvpkit'
+            },
+            tiktok: {
+                handle: '@mvpkittok',
+                url: 'https://tiktok.com/@mvpkittok'
             }
         },
-        {
-            type: 'confirm',
-            name: 'git',
-            message: 'Create git repository?',
-            default: true
-        },
-    ]);
-    console.log(); // Add spacing after prompts
-    const updatedVariables = {
-        ...variables,
-        projectDescription: answers.description,
-        domainName: answers.domain || undefined,
-        packageScope: answers.packageScope,
-        frontendPackageName: `${answers.packageScope}/frontend`,
-        backendPackageName: `${answers.packageScope}/backend`,
-        apiPackageName: `${answers.packageScope}/api`,
-        configPackageName: `${answers.packageScope}/config`
-    };
-    // Ensure projectKebabCase is never empty or undefined
-    if (!updatedVariables.projectKebabCase) {
-        console.warn('Warning: projectKebabCase is empty, using projectName as fallback');
-        updatedVariables.projectKebabCase = projectName.toLowerCase().replace(/[_\s]+/g, '-');
-    }
-    const updatedOptions = {
-        ...options,
-        install: true, // Always install dependencies
-        git: answers.git,
-        setupDb: true, // Always setup database locally
-        setupShadcn: true // Always setup shadcn
+        packageManager: 'pnpm', // Default, will be updated by prompts if needed
+        packageManagerVersion: '9.0.0' // Default, will be updated by prompts if needed
     };
-    return { updatedVariables, updatedOptions };
+    // CLI mode with interactive prompts
+    // Collect missing variables interactively
+    const finalVariables = await collectVariables(variables, options);
+    const templateLabel = (finalVariables.template || 'core').toUpperCase();
+    console.log(chalk.blue(`🚀 Creating ${projectName} with MVPKit ${templateLabel}\n`));
+    try {
+        // Resolve template path once to avoid duplicate downloads/work.
+        const resolvedTemplatePath = await getTemplatePath({ ...options, template: finalVariables.template });
+        const resolvedOptions = {
+            ...options,
+            template: finalVariables.template,
+            templatePath: resolvedTemplatePath
+        };
+        // Copy template and complete setup using shared functionality
+        await copyTemplate(targetDir, finalVariables, resolvedOptions);
+        await completeProjectSetup(targetDir, finalVariables, resolvedOptions);
+        // Success!
+        console.log('\n' + chalk.green('🎉 Project Created Successfully!'));
+        console.log(chalk.white.dim('═'.repeat(50)));
+        console.log(chalk.green(`✅ ${projectName} is ready to go!`));
+        // Next steps
+        const extendedOptions = { ...options, componentPack: finalVariables.componentPack };
+        printNextSteps(projectName, extendedOptions, finalVariables.packageManager);
+    }
+    catch (error) {
+        // Clean up on failure
+        if (fs.existsSync(targetDir)) {
+            await fs.remove(targetDir);
+        }
+        throw error;
+    }
 }
-async function copyAndTransformTemplate(targetDir, variables, templatePath, packageManagerInfo) {
-    const coreDir = templatePath || getCoreRepositoryPath();
-    if (!fs.existsSync(coreDir)) {
-        throw new Error(`Template directory not found at ${coreDir}`);
-    }
-    // Get all files from core directory with optimized glob pattern
-    const files = await glob('**/*', {
-        cwd: coreDir,
-        dot: true,
-        nodir: true,
-        absolute: false
-    });
-    // Process each file
-    for (const sourceFile of files) {
-        const sourcePath = path.join(coreDir, sourceFile);
-        const relativePath = sourceFile;
-        // Create package-manager specific skip patterns
-        const skipPatterns = [...DEFAULT_SKIP_PATTERNS];
-        if (variables.packageManager === 'bun') {
-            skipPatterns.push('pnpm-workspace.yaml');
+/**
+ * Initialize shadcn/ui ONLY in packages/ui using the official shadcn CLI
+ */
+async function initShadcnInUIPackage(uiPath, style, interactive) {
+    const viteConfigPath = path.join(uiPath, 'vite.config.ts');
+    try {
+        // Create temporary vite.config.ts for framework detection
+        const viteConfig = `import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+})
+`;
+        fs.writeFileSync(viteConfigPath, viteConfig);
+        if (interactive) {
+            // In interactive mode, let users choose through prompts, force override existing config
+            execSync('npx shadcn@latest init -f -s', {
+                cwd: uiPath,
+                stdio: 'inherit',
+                timeout: 60000 // 60 second timeout for CLI init
+            });
         }
-        // Skip files we don't want to copy
-        if (shouldSkipFile(relativePath, skipPatterns)) {
-            continue;
+        else {
+            // In non-interactive mode, use specific defaults (new-york, zinc) with -y flag and force override
+            execSync('npx shadcn@latest init -y -f -s -b zinc', {
+                cwd: uiPath,
+                stdio: 'pipe',
+                timeout: 60000 // 60 second timeout for CLI init
+            });
         }
-        // Check if this is a template file (.template/.tpl)
-        const isTemplateFile = relativePath.endsWith('.template') || relativePath.endsWith('.tpl');
-        // Transform the file path if needed
-        let targetRelativePath;
-        if (isTemplateFile) {
-            // For template files, remove template extension and transform filename
-            targetRelativePath = transformTemplateFileName(relativePath, variables);
+    }
+    catch (error) {
+        throw new Error(`Failed to initialize shadcn/ui in UI package: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        // Clean up temporary vite.config.ts
+        if (fs.existsSync(viteConfigPath)) {
+            fs.unlinkSync(viteConfigPath);
         }
-        else {
-            // For regular files, just transform filename
-            targetRelativePath = transformFileName(relativePath, variables);
+    }
+}
+/**
+ * Install a component pack in the UI package
+ */
+async function installComponentPack(uiPath, packName, interactive, templateConfig) {
+    const spinner = ora(`  Adding ${packName} component library...`).start();
+    try {
+        if (packName === 'all') {
+            // Use shadcn --all flag for bulk installation
+            const addArgs = [
+                'add',
+                interactive ? '' : '-y',
+                '--overwrite',
+                '--all'
+            ].filter(Boolean);
+            execSync(`npx shadcn@latest ${addArgs.join(' ')}`, {
+                cwd: uiPath,
+                stdio: 'pipe',
+                timeout: 120000 // 2 minute timeout for bulk install
+            });
         }
-        const targetFile = path.join(targetDir, targetRelativePath);
-        // Ensure target directory exists
-        await fs.ensureDir(path.dirname(targetFile));
-        try {
-            // Read source file
-            const content = await fs.readFile(sourcePath, 'utf8');
-            // Get appropriate transformation function
-            const fileName = path.basename(sourceFile);
-            const transformFunction = getFileTransformFunction(fileName, isTemplateFile);
-            // Transform content
-            const transformedContent = transformFunction(content, variables);
-            // Special handling for package.json - remove workspaces to prevent nested workspace issues
-            if (targetRelativePath.endsWith('package.json') && !targetRelativePath.includes('node_modules')) {
-                try {
-                    const pkg = JSON.parse(transformedContent);
-                    // Remove workspaces from generated projects to prevent nested workspace conflicts
-                    if (pkg.workspaces) {
-                        delete pkg.workspaces;
-                    }
-                    // Also remove pnpm overrides if they exist
-                    if (pkg.pnpm && pkg.pnpm.overrides) {
-                        delete pkg.pnpm.overrides;
-                    }
-                    const finalContent = JSON.stringify(pkg, null, 2);
-                    await fs.writeFile(targetFile, finalContent);
-                }
-                catch {
-                    // If JSON parsing fails, write as-is
-                    await fs.writeFile(targetFile, transformedContent);
-                }
+        else {
+            // Use template config if available, otherwise use default component packs
+            const componentPacks = templateConfig?.componentPacks || {
+                basic: { components: ['button', 'card', 'input', 'label', 'separator'] }
+            };
+            if (!(packName in componentPacks)) {
+                throw new Error(`Unknown component pack: ${packName}. Available packs: ${Object.keys(componentPacks).join(', ')}`);
             }
-            else {
-                // Write transformed content
-                await fs.writeFile(targetFile, transformedContent);
+            const components = componentPacks[packName].components;
+            // Install components individually
+            for (const component of components) {
+                const addArgs = [
+                    'add',
+                    interactive ? '' : '-y',
+                    '--overwrite',
+                    component
+                ].filter(Boolean);
+                execSync(`npx shadcn@latest ${addArgs.join(' ')}`, {
+                    cwd: uiPath,
+                    stdio: 'pipe',
+                    timeout: 30000 // 30 second timeout per component
+                });
             }
         }
-        catch (error) {
-            // If file is binary or can't be read as text, copy as-is
-            await fs.copy(sourcePath, targetFile);
-        }
+        spinner.succeed(`  ✅ ${packName} component library ready`);
     }
-    // Create additional setup files
-    if (packageManagerInfo) {
-        await createSetupFiles(targetDir, variables, packageManagerInfo);
+    catch (error) {
+        spinner.fail(`  ❌ ${packName} component library installation failed`);
+        throw new Error(`Failed to install ${packName} component library: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-async function createSetupFiles(targetDir, variables, packageManagerInfo) {
-    // Create .env.example files with proper variable names
-    const frontendEnvExample = `# Frontend Environment Variables
-VITE_API_URL=http://localhost:8787
-VITE_APP_NAME="${variables.projectDisplayName}"
-${variables.domainName ? `VITE_APP_DOMAIN=${variables.domainName}` : '# VITE_APP_DOMAIN=your-domain.com'}
-`;
-    const backendDevVarsExample = `# Backend Development Variables
-# Database
-DATABASE_URL="file:./dev.db"
-
-# Auth (generate your own secrets)
-# AUTH_SECRET="your-secret-key-here"
-# GITHUB_CLIENT_ID="your-github-client-id"
-# GITHUB_CLIENT_SECRET="your-github-client-secret"
-
-# Email (optional)
-# SMTP_HOST="smtp.gmail.com"
-# SMTP_PORT="587"
-# SMTP_USER="your-email@gmail.com"
-# SMTP_PASSWORD="your-password"
-`;
-    await fs.writeFile(path.join(targetDir, 'apps/frontend/.env.example'), frontendEnvExample);
-    await fs.writeFile(path.join(targetDir, 'apps/backend/.dev.vars.example'), backendDevVarsExample);
-    // Create a project-specific README
-    const readmeContent = `# ${variables.projectDisplayName}
-
-${variables.projectDescription}
-
-Built with [MVPKit Core](https://mvpkit.dev) - A production-ready Cloudflare-native starter.
-
-## Quick Start
-
-\`\`\`bash
-# Install dependencies
-${getPackageManagerCommand(packageManagerInfo)} install
-
-# Set up environment variables
-cp apps/frontend/.env.example apps/frontend/.env.local
-cp apps/backend/.dev.vars.example apps/backend/.dev.vars
-
-# Set up database (if not done during project creation)
-# cd apps/backend
-# ${getPackageManagerCommand(packageManagerInfo)} db:migrate:local
-# ${getPackageManagerCommand(packageManagerInfo)} db:seed:local
-
-# Start development servers
-${getPackageManagerCommand(packageManagerInfo)} dev
-\`\`\`
-
-Visit [http://localhost:5173](http://localhost:5173) to see your application!
-
-## Project Structure
-
-- \`apps/frontend/\` - React application with Vite
-- \`apps/backend/\` - Cloudflare Workers API with Hono
-- \`packages/api/\` - Shared API types
-- \`packages/config/\` - Shared configuration
-
-## Features
-
-- 🚀 **Cloudflare Stack**: Workers, Pages, D1, KV, R2
-- ⚡ **Modern Frontend**: React 19, TanStack Router & Query
-- 🎨 **Styling**: Tailwind CSS v4 + shadcn/ui components
-- 🔐 **Authentication**: Better Auth with social providers
-- 🗄️ **Database**: D1 with Drizzle ORM
-- 📡 **Type-Safe APIs**: tRPC for end-to-end type safety
-- 🏗️ **Monorepo**: Turbo for fast builds and caching
-
-## Development Commands
-
-\`\`\`bash
-${getPackageManagerCommand(packageManagerInfo)} dev          # Start development servers
-${getPackageManagerCommand(packageManagerInfo)} build        # Build all packages
-${getPackageManagerCommand(packageManagerInfo)} lint         # Lint all packages
-${getPackageManagerCommand(packageManagerInfo)} typecheck    # Type check all packages
-${getPackageManagerCommand(packageManagerInfo)} test         # Run tests
-\`\`\`
-
-## Deployment
-
-\`\`\`bash
-# Deploy backend to Cloudflare Workers
-${getPackageManagerCommand(packageManagerInfo)} deploy:backend
-
-# Deploy frontend to Cloudflare Pages
-${getPackageManagerCommand(packageManagerInfo)} deploy:frontend
-
-# Deploy both
-${getPackageManagerCommand(packageManagerInfo)} deploy:apps
-\`\`\`
-
-## Learn More
-
-- [MVPKit Website](https://mvpkit.dev)
-- [MVPKit Documentation](https://docs.mvpkit.dev)
-- [MVPKit Examples](https://github.com/mvp-kit/core/examples)
-`;
-    await fs.writeFile(path.join(targetDir, 'README.md'), readmeContent);
+/**
+ * Inherit UI package configuration to web app components.json
+ * Web app gets config but NOT styles.css (styles come from UI package)
+ */
+async function inheritUIConfigToWeb(uiPath, webPath) {
+    const uiComponentsPath = path.join(uiPath, 'components.json');
+    const webComponentsPath = path.join(webPath, 'components.json');
+    if (!fs.existsSync(uiComponentsPath)) {
+        throw new Error('UI package components.json not found - cannot inherit configuration');
+    }
+    try {
+        const uiConfig = JSON.parse(fs.readFileSync(uiComponentsPath, 'utf-8'));
+        const webConfigCurrent = fs.existsSync(webComponentsPath)
+            ? JSON.parse(fs.readFileSync(webComponentsPath, 'utf-8'))
+            : {};
+        // Create web-specific config inheriting style/theme from UI while preserving web paths.
+        const webConfig = {
+            ...webConfigCurrent,
+            style: uiConfig.style ?? webConfigCurrent.style,
+            rsc: uiConfig.rsc ?? webConfigCurrent.rsc,
+            tsx: uiConfig.tsx ?? webConfigCurrent.tsx,
+            tailwind: {
+                ...(webConfigCurrent.tailwind || {}),
+                ...uiConfig.tailwind,
+                css: webConfigCurrent?.tailwind?.css || 'src/styles.css'
+            },
+            aliases: {
+                ...(uiConfig.aliases || {}),
+                ...(webConfigCurrent.aliases || {})
+            },
+            registries: webConfigCurrent.registries || {}
+        };
+        await fs.writeJson(webComponentsPath, webConfig, { spaces: 2 });
+    }
+    catch (error) {
+        throw new Error(`Failed to inherit UI config to web: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
-async function setupShadcn(targetDir, packageManager, options = {}) {
-    console.log();
-    console.log(drawBox([
-        'Setting up shadcn/ui component library',
-        'Configure your preferences, then we\'ll install essential components'
-    ], 'Component Setup'));
-    console.log();
-    const frontendDir = path.join(targetDir, 'apps', 'frontend');
-    let componentSpinner = null;
+/**
+ * Copy template files and process .template files
+ */
+export async function copyTemplate(targetDir, variables, options = {}) {
+    const spinner = ora('Setting up project structure...').start();
     try {
-        // Initialize shadcn
-        try {
-            if (options.interactive === false) {
-                // Non-interactive mode with zinc theme
-                execSync('npx shadcn@latest init -s -b zinc --yes', {
-                    cwd: frontendDir,
-                    stdio: 'pipe'
-                });
+        const coreDir = await getTemplatePath(options);
+        // Get all files from core directory
+        const files = await glob('**/*', {
+            cwd: coreDir,
+            dot: true,
+            nodir: true,
+            absolute: false
+        });
+        // Process each file
+        for (const sourceFile of files) {
+            const sourcePath = path.join(coreDir, sourceFile);
+            // Skip unwanted files based on .templateignore
+            if (shouldSkipFile(sourceFile, coreDir)) {
+                continue;
+            }
+            // Determine target path
+            const targetFile = path.join(targetDir, getTargetFilePath(sourceFile));
+            // Ensure target directory exists
+            await fs.ensureDir(path.dirname(targetFile));
+            // Process template files
+            if (sourceFile.endsWith('.template')) {
+                const content = await fs.readFile(sourcePath, 'utf8');
+                const processedContent = processTemplate(content, variables);
+                await fs.writeFile(targetFile, processedContent);
             }
             else {
-                // Interactive mode - temporarily restore cursor and handle signals
-                process.stdout.write('\x1B[?25h'); // Show cursor
-                console.log(chalk.gray('⌨️  Press Ctrl+C to cancel shadcn setup if needed'));
-                execSync('npx shadcn@latest init -s', {
-                    cwd: frontendDir,
-                    stdio: 'inherit',
-                    killSignal: 'SIGKILL'
-                });
+                // Copy regular files as-is
+                await fs.copy(sourcePath, targetFile);
             }
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            // Check if user cancelled (Ctrl+C)
-            if (errorMessage.includes('SIGINT') || errorMessage.includes('cancelled')) {
-                console.log(chalk.yellow('\n🛑 Cancelled'));
-                process.exit(0);
-            }
-            console.log(chalk.yellow('⚠️  shadcn setup failed, skipping component installation'));
-            console.log(chalk.gray(`   ${errorMessage}`));
-            return; // Exit shadcn setup entirely if init failed
+        spinner.succeed('Project structure created');
+    }
+    catch (error) {
+        spinner.fail('Project structure creation failed');
+        throw error;
+    }
+}
+/**
+ * Copy package manager specific files from _packageManagers directory
+ */
+export async function copyPackageManagerFiles(targetDir, variables, options = {}) {
+    const spinner = ora('Configuring package manager...').start();
+    try {
+        const coreDir = await getTemplatePath(options);
+        const packageManagerDir = path.join(coreDir, '_packageManagers', variables.packageManager);
+        // Check if package manager directory exists
+        if (!fs.existsSync(packageManagerDir)) {
+            spinner.succeed('Package manager configuration complete');
+            return;
         }
-        // Install shadcn components
-        componentSpinner = ora('Installing components...').start();
-        const components = ['alert', 'badge', 'button', 'card', 'input', 'label'];
-        for (const component of components) {
-            try {
-                execSync(`npx shadcn@latest add ${component} -s --overwrite --yes`, {
-                    cwd: frontendDir,
-                    stdio: 'inherit'
-                });
+        // Get all files from package manager directory
+        const files = await glob('**/*', {
+            cwd: packageManagerDir,
+            dot: true,
+            nodir: true,
+            absolute: false
+        });
+        // Copy each file to the target directory root
+        for (const file of files) {
+            const sourcePath = path.join(packageManagerDir, file);
+            const targetFile = path.join(targetDir, file);
+            // Ensure target directory exists
+            await fs.ensureDir(path.dirname(targetFile));
+            // Process template files if they have .template extension
+            if (file.endsWith('.template')) {
+                const content = await fs.readFile(sourcePath, 'utf8');
+                const processedContent = processTemplate(content, variables);
+                const finalTargetFile = targetFile.replace(/\.template$/, '');
+                await fs.writeFile(finalTargetFile, processedContent);
             }
-            catch {
-                try {
-                    execSync(`npx shadcn@latest add ${component} -s --yes`, {
-                        cwd: frontendDir,
-                        stdio: 'inherit'
-                    });
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    console.log(chalk.yellow(`⚠️  Failed to install ${component}`));
-                    console.log(chalk.gray(`   Error: ${errorMessage}`));
-                }
+            else {
+                // Copy regular files as-is
+                await fs.copy(sourcePath, targetFile);
             }
         }
-        componentSpinner?.succeed('Components installed');
+        spinner.succeed(`Configured for ${variables.packageManager}`);
     }
     catch (error) {
-        componentSpinner?.fail('Setup failed');
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.log(chalk.yellow('💡 Run manually: npx shadcn@latest init'));
-        console.log(chalk.gray(`   Error: ${errorMessage}`));
+        spinner.fail('Package manager configuration failed');
+        console.log(chalk.yellow(`   Warning: ${error instanceof Error ? error.message : String(error)}`));
     }
 }
-function printNextSteps(projectName, options, dbSetupCompleted = false, packageManager = 'pnpm') {
-    const pmCommand = getPackageManagerCommand({ pm: packageManager, version: packageManager === 'pnpm' ? '10.14.0' : 'latest' });
-    // Build next steps list
-    const steps = [`1. cd ${projectName}`];
-    let step = 2;
-    if (!options.install) {
-        steps.push(`${step}. ${pmCommand} install`);
-        step++;
-    }
-    steps.push(`${step}. cp apps/frontend/.env.example apps/frontend/.env.local`);
-    step++;
-    steps.push(`${step}. cp apps/backend/.dev.vars.example apps/backend/.dev.vars`);
-    step++;
-    if (!dbSetupCompleted) {
-        steps.push(`${step}. cd apps/backend`);
-        step++;
-        steps.push(`${step}. ${pmCommand} db:generate`);
-        step++;
-        steps.push(`${step}. ${pmCommand} db:migrate:local`);
-        step++;
-        steps.push(`${step}. cd ../..`);
-        step++;
-    }
-    steps.push(`${step}. ${pmCommand} dev`);
-    console.log(drawBox(steps, 'Next Steps'));
-    console.log();
-    console.log(drawBox([
-        '🌐 Website: https://mvpkit.dev',
-        '📖 Documentation: https://docs.mvpkit.dev',
-        '🔗 Examples: https://github.com/mvp-kit/core/examples'
-    ], 'Resources'));
-    console.log();
-    console.log(chalk.bold.green('🚀 Happy building with MVPKit!'));
-    console.log();
+/**
+ * Install dependencies
+ */
+async function installDependencies(targetDir, packageManager) {
+    const spinner = ora('Installing packages...').start();
+    try {
+        const command = packageManager === 'bun' ? 'bun install' : 'pnpm install';
+        execSync(command, {
+            cwd: targetDir,
+            stdio: 'pipe'
+        });
+        spinner.succeed('All packages installed');
+    }
+    catch (error) {
+        spinner.fail('Package installation failed');
+        console.log(chalk.yellow(`\n💡 Install packages manually: cd ${path.basename(targetDir)} && ${packageManager} install\n`));
+    }
+}
+/**
+ * Setup database with Drizzle ORM
+ */
+async function setupDatabase(apiPath, packageManager) {
+    const spinner = ora('Setting up database...').start();
+    try {
+        const pmCommand = packageManager === 'bun' ? 'bun' : 'pnpm';
+        // Initialize local database
+        execSync(`${pmCommand} run db:init`, {
+            cwd: apiPath,
+            stdio: 'pipe',
+            timeout: 30000
+        });
+        // Generate database schema
+        execSync(`${pmCommand} run db:generate`, {
+            cwd: apiPath,
+            stdio: 'pipe',
+            timeout: 60000
+        });
+        // Run local migrations
+        execSync(`${pmCommand} run db:migrate:local`, {
+            cwd: apiPath,
+            stdio: 'pipe',
+            timeout: 60000
+        });
+        spinner.succeed('Database setup completed');
+    }
+    catch (error) {
+        spinner.fail('Database setup failed');
+        console.log(chalk.yellow(`\n💡 Setup database manually: cd ${path.basename(apiPath)} && ${packageManager} run db:generate && ${packageManager} run db:migrate:local\n`));
+    }
+}
+/**
+ * Run lint:fix command if available
+ */
+async function runLintFixCommand(targetDir, packageManager) {
+    const spinner = ora('Fixing code formatting...').start();
+    try {
+        const pmCommand = packageManager === 'pnpm' ? 'pnpm' : 'bun';
+        execSync(`${pmCommand} run lint:fix`, {
+            cwd: targetDir,
+            stdio: 'pipe',
+            timeout: 60000 // 60 second timeout
+        });
+        spinner.succeed('Code formatted and linted');
+    }
+    catch (error) {
+        // If lint:fix fails or doesn't exist, try just lint
+        try {
+            const pmCommand = packageManager === 'pnpm' ? 'pnpm' : 'bun';
+            execSync(`${pmCommand} run lint`, {
+                cwd: targetDir,
+                stdio: 'pipe',
+                timeout: 60000
+            });
+            spinner.succeed('Code formatting verified');
+        }
+        catch (lintError) {
+            // If no lint command exists, skip silently
+            spinner.succeed('Code formatting completed');
+        }
+    }
+}
+/**
+ * Initialize git repository with commit (after lint:fix)
+ */
+async function initializeGitWithCommit(targetDir) {
+    const spinner = ora('Initializing version control...').start();
+    try {
+        execSync('git init', { cwd: targetDir, stdio: 'pipe' });
+        execSync('git add .', { cwd: targetDir, stdio: 'pipe' });
+        execSync('git commit -m "Initial commit from MVPKit Create CLI"', { cwd: targetDir, stdio: 'pipe' });
+        spinner.succeed('Version control initialized with initial commit');
+    }
+    catch (error) {
+        spinner.fail('Version control initialization failed');
+        console.log(chalk.yellow('\n💡 Initialize version control manually if needed\n'));
+    }
+}
+/**
+ * Initialize git repository (legacy function for compatibility)
+ */
+async function initializeGit(targetDir) {
+    const spinner = ora('Initializing version control...').start();
+    try {
+        execSync('git init', { cwd: targetDir, stdio: 'pipe' });
+        execSync('git add .', { cwd: targetDir, stdio: 'pipe' });
+        execSync('git commit -m "Initial commit"', { cwd: targetDir, stdio: 'pipe' });
+        spinner.succeed('Version control initialized');
+    }
+    catch (error) {
+        spinner.fail('Version control initialization failed');
+        console.log(chalk.yellow('\n💡 Initialize version control manually if needed\n'));
+    }
+}
+/**
+ * Print next steps
+ */
+function printNextSteps(projectName, options, packageManager) {
+    const pmCommand = packageManager === 'bun' ? 'bun' : 'pnpm';
+    console.log('\n' + chalk.cyan('🚀 Get Started'));
+    console.log(chalk.white.dim('═'.repeat(50)));
+    // Step-by-step instructions
+    console.log(chalk.bold('Next steps:'));
+    console.log(chalk.green(`  1. cd ${projectName}`));
+    if (options.install === false) {
+        console.log(chalk.green(`  2. ${pmCommand} install`));
+        console.log(chalk.green(`  3. ${pmCommand} dev`));
+    }
+    else {
+        console.log(chalk.green(`  2. ${pmCommand} dev`));
+    }
+    console.log(chalk.green(`  3. Open http://localhost:3001 (web) and http://localhost:3002 (app)`));
+    // What's included section
+    console.log('\n' + chalk.whiteBright.bold('🎁 What\'s Included:'));
+    const features = [
+        '⚡ Full-stack TypeScript with hot reload',
+        '🗄️  Database with Drizzle ORM + migrations',
+        '🎨 shadcn/ui components with new-york theme',
+        '🔐 Authentication with better-auth',
+        '🌐 Dual surfaces: apps/web (marketing) + apps/app (authenticated app)',
+        '📦 Monorepo structure (apps + packages + services)',
+        '🔧 ESLint, Prettier, and TypeScript configured'
+    ];
+    if (options.componentPack && options.componentPack === 'all') {
+        features.splice(2, 1, `🎨 shadcn/ui complete component library + new-york theme`);
+    }
+    else if (options.componentPack) {
+        features.splice(2, 1, `🎨 shadcn/ui essentials component pack + new-york theme`);
+    }
+    features.forEach(feature => {
+        console.log(chalk.white(`  ${feature}`));
+    });
+    // Quick tips
+    console.log('\n' + chalk.whiteBright.bold('💡 Quick Tips:'));
+    console.log(chalk.white('  • Database is already set up and migrated'));
+    console.log(chalk.white('  • Add more components: npx shadcn@latest add <component>'));
+    console.log(chalk.white('  • Customize UI theme in packages/ui/src/styles.css'));
+    console.log(chalk.white('  • API handlers are in services/api/src/trpc/ and services/api/src/app.ts'));
+    console.log('\n' + chalk.bold('📚 Learn More:'));
+    console.log(chalk.blue('  https://docs.mvpkit.dev'));
+    console.log(chalk.white('  https://ui.shadcn.com (for UI components)'));
+    console.log(chalk.white('  https://orm.drizzle.team (for database)'));
+    console.log(chalk.white(''));
 }
 //# sourceMappingURL=create.js.map