create-fluxstack 1.7.5 → 1.8.3

package/core/utils/build-logger.ts

@@ -0,0 +1,324 @@
+/**
+ * FluxStack Build Logger - Beautiful terminal output for build process
+ * Provides formatted tables, boxes, and colored output
+ */
+
+// ANSI Color codes
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+
+  // Text colors
+  cyan: '\x1b[36m',
+  blue: '\x1b[34m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+
+  // Background colors
+  bgCyan: '\x1b[46m',
+  bgBlue: '\x1b[44m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgRed: '\x1b[41m',
+}
+
+// Box drawing characters
+const box = {
+  topLeft: '╭',
+  topRight: '╮',
+  bottomLeft: '╰',
+  bottomRight: '╯',
+  horizontal: '─',
+  vertical: '│',
+  verticalRight: '├',
+  verticalLeft: '┤',
+  horizontalDown: '┬',
+  horizontalUp: '┴',
+  cross: '┼',
+}
+
+export interface TableColumn {
+  header: string
+  key: string
+  width?: number
+  align?: 'left' | 'right' | 'center'
+  color?: keyof typeof colors
+}
+
+export interface TableRow {
+  [key: string]: string | number
+}
+
+export class BuildLogger {
+  private indent = ''
+  private startTime = Date.now()
+
+  /**
+   * Print a beautiful header banner
+   */
+  header(title: string) {
+    const width = 60
+    const padding = Math.floor((width - title.length - 2) / 2)
+    const paddingRight = width - title.length - 2 - padding
+
+    console.log()
+    console.log(colors.cyan + colors.bright + box.topLeft + box.horizontal.repeat(width) + box.topRight + colors.reset)
+    console.log(colors.cyan + box.vertical + ' '.repeat(padding) + colors.bright + colors.white + title + colors.cyan + ' '.repeat(paddingRight) + box.vertical + colors.reset)
+    console.log(colors.cyan + box.bottomLeft + box.horizontal.repeat(width) + box.bottomRight + colors.reset)
+    console.log()
+  }
+
+  /**
+   * Print a section header
+   */
+  section(title: string, icon: string = '📦') {
+    console.log()
+    console.log(colors.bright + colors.blue + `${icon}  ${title}` + colors.reset)
+    console.log(colors.dim + colors.gray + box.horizontal.repeat(50) + colors.reset)
+  }
+
+  /**
+   * Print a success message
+   */
+  success(message: string) {
+    console.log(colors.green + '✓ ' + colors.reset + message)
+  }
+
+  /**
+   * Print an error message
+   */
+  error(message: string) {
+    console.log(colors.red + '✗ ' + colors.reset + message)
+  }
+
+  /**
+   * Print a warning message
+   */
+  warn(message: string) {
+    console.log(colors.yellow + '⚠ ' + colors.reset + message)
+  }
+
+  /**
+   * Print an info message
+   */
+  info(message: string, icon: string = '→') {
+    console.log(colors.cyan + icon + ' ' + colors.reset + message)
+  }
+
+  /**
+   * Print a step message
+   */
+  step(message: string, icon: string = '▸') {
+    console.log(colors.dim + colors.gray + icon + ' ' + colors.reset + message)
+  }
+
+  /**
+   * Print a table
+   */
+  table(columns: TableColumn[], rows: TableRow[]) {
+    if (rows.length === 0) {
+      this.warn('No data to display')
+      return
+    }
+
+    // Calculate column widths
+    const widths = columns.map(col => {
+      if (col.width) return col.width
+      const maxContentWidth = Math.max(
+        col.header.length,
+        ...rows.map(row => String(row[col.key] || '').length)
+      )
+      return Math.min(maxContentWidth, 40) // Max 40 chars per column
+    })
+
+    const totalWidth = widths.reduce((sum, w) => sum + w, 0) + (columns.length - 1) * 3 + 4
+
+    // Print top border
+    console.log(
+      colors.gray + box.topLeft +
+      widths.map((w, i) =>
+        box.horizontal.repeat(w + 2) + (i < widths.length - 1 ? box.horizontalDown : '')
+      ).join('') +
+      box.topRight + colors.reset
+    )
+
+    // Print header
+    const headerRow = columns.map((col, i) => {
+      const content = this.padContent(col.header, widths[i], 'center')
+      return colors.bright + colors.white + content + colors.reset
+    }).join(colors.gray + ' │ ' + colors.reset)
+
+    console.log(colors.gray + box.vertical + ' ' + colors.reset + headerRow + colors.gray + ' ' + box.vertical + colors.reset)
+
+    // Print header separator
+    console.log(
+      colors.gray + box.verticalRight +
+      widths.map((w, i) =>
+        box.horizontal.repeat(w + 2) + (i < widths.length - 1 ? box.cross : '')
+      ).join('') +
+      box.verticalLeft + colors.reset
+    )
+
+    // Print rows
+    rows.forEach((row, rowIndex) => {
+      const rowContent = columns.map((col, i) => {
+        const value = String(row[col.key] || '')
+        const content = this.padContent(value, widths[i], col.align || 'left')
+        const color = col.color ? colors[col.color] : ''
+        return color + content + colors.reset
+      }).join(colors.gray + ' │ ' + colors.reset)
+
+      console.log(colors.gray + box.vertical + ' ' + colors.reset + rowContent + colors.gray + ' ' + box.vertical + colors.reset)
+    })
+
+    // Print bottom border
+    console.log(
+      colors.gray + box.bottomLeft +
+      widths.map((w, i) =>
+        box.horizontal.repeat(w + 2) + (i < widths.length - 1 ? box.horizontalUp : '')
+      ).join('') +
+      box.bottomRight + colors.reset
+    )
+  }
+
+  /**
+   * Print a simple info box
+   */
+  box(title: string, items: Array<{ label: string; value: string | number; color?: keyof typeof colors }>) {
+    const maxLabelWidth = Math.max(...items.map(i => i.label.length))
+    const maxValueWidth = Math.max(...items.map(i => String(i.value).length))
+    const contentWidth = maxLabelWidth + maxValueWidth + 3
+    const boxWidth = Math.max(contentWidth, title.length) + 4
+
+    // Top border with title
+    console.log()
+    console.log(colors.cyan + box.topLeft + box.horizontal.repeat(2) + colors.bright + colors.white + title + colors.cyan + box.horizontal.repeat(boxWidth - title.length - 2) + box.topRight + colors.reset)
+
+    // Content
+    items.forEach(item => {
+      const label = item.label.padEnd(maxLabelWidth)
+      const value = String(item.value)
+      const valueColor = item.color ? colors[item.color] : colors.white
+      console.log(
+        colors.cyan + box.vertical + ' ' + colors.reset +
+        colors.gray + label + colors.reset +
+        colors.dim + ' : ' + colors.reset +
+        valueColor + colors.bright + value + colors.reset +
+        ' '.repeat(boxWidth - label.length - value.length - 3) +
+        colors.cyan + box.vertical + colors.reset
+      )
+    })
+
+    // Bottom border
+    console.log(colors.cyan + box.bottomLeft + box.horizontal.repeat(boxWidth) + box.bottomRight + colors.reset)
+    console.log()
+  }
+
+  /**
+   * Print a progress indicator
+   */
+  progress(current: number, total: number, label: string) {
+    const percentage = Math.round((current / total) * 100)
+    const barLength = 30
+    const filled = Math.round((percentage / 100) * barLength)
+    const empty = barLength - filled
+
+    const bar = colors.green + '█'.repeat(filled) + colors.gray + '░'.repeat(empty) + colors.reset
+    console.log(`${label} [${bar}] ${percentage}% (${current}/${total})`)
+  }
+
+  /**
+   * Start a timer
+   */
+  startTimer(label?: string) {
+    this.startTime = Date.now()
+    if (label) {
+      this.info(label, '⏱')
+    }
+  }
+
+  /**
+   * End timer and print elapsed time
+   */
+  endTimer(label: string = 'Completed') {
+    const elapsed = Date.now() - this.startTime
+    const seconds = (elapsed / 1000).toFixed(2)
+    this.success(`${label} in ${colors.bright}${seconds}s${colors.reset}`)
+  }
+
+  /**
+   * Print a summary box
+   */
+  summary(title: string, stats: Array<{ label: string; value: string | number; highlight?: boolean }>) {
+    console.log()
+    console.log(colors.bright + colors.green + '╔═══════════════════════════════════════════════════════════╗' + colors.reset)
+    console.log(colors.bright + colors.green + '║' + colors.reset + colors.bright + colors.white + ` ${title}`.padEnd(60) + colors.bright + colors.green + '║' + colors.reset)
+    console.log(colors.bright + colors.green + '╠═══════════════════════════════════════════════════════════╣' + colors.reset)
+
+    stats.forEach(stat => {
+      const label = `  ${stat.label}:`
+      const value = String(stat.value)
+      const valueColor = stat.highlight ? colors.yellow + colors.bright : colors.white
+      const padding = 60 - label.length - value.length - 1
+      console.log(
+        colors.bright + colors.green + '║' + colors.reset +
+        colors.cyan + label + colors.reset +
+        ' '.repeat(Math.max(padding, 1)) +
+        valueColor + value + colors.reset +
+        colors.bright + colors.green + ' ║' + colors.reset
+      )
+    })
+
+    console.log(colors.bright + colors.green + '╚═══════════════════════════════════════════════════════════╝' + colors.reset)
+    console.log()
+  }
+
+  /**
+   * Pad content based on alignment
+   */
+  private padContent(content: string, width: number, align: 'left' | 'right' | 'center' = 'left'): string {
+    if (content.length >= width) {
+      return content.slice(0, width)
+    }
+
+    const padding = width - content.length
+
+    switch (align) {
+      case 'right':
+        return ' '.repeat(padding) + content
+      case 'center':
+        const leftPad = Math.floor(padding / 2)
+        const rightPad = padding - leftPad
+        return ' '.repeat(leftPad) + content + ' '.repeat(rightPad)
+      default:
+        return content + ' '.repeat(padding)
+    }
+  }
+
+  /**
+   * Format file size
+   */
+  formatSize(bytes: number): string {
+    if (bytes === 0) return '0 B'
+    const k = 1024
+    const sizes = ['B', 'KB', 'MB', 'GB']
+    const i = Math.floor(Math.log(bytes) / Math.log(k))
+    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`
+  }
+
+  /**
+   * Format duration
+   */
+  formatDuration(ms: number): string {
+    if (ms < 1000) return `${ms}ms`
+    return `${(ms / 1000).toFixed(2)}s`
+  }
+}
+
+// Export singleton instance
+export const buildLogger = new BuildLogger()

package/core/utils/config-schema.ts

@@ -23,17 +23,13 @@
  *     default: 3000,
  *     validate: (value) => value > 0 && value < 65536
  *   },
- *   debug: {
- *     type: 'boolean',
- *     env: 'DEBUG',
- *     default: false
- *   }
+ *   env: config.enum('NODE_ENV', ['development', 'production', 'test'] as const, 'development', true)
  * })
  *
  * // Access with full type safety
  * appConfig.name   // string
  * appConfig.port   // number
- * appConfig.debug  // boolean
+ * appConfig.env    // "development" | "production" | "test"
  * ```
  */
 

package/core/utils/helpers.ts

@@ -86,22 +86,27 @@ export const throttle = <T extends (...args: any[]) => any>(
   }
 }
 
+/**
+ * Environment detection utilities
+ * Uses declarative config system instead of legacy env
+ */
+
 export const isProduction = (): boolean => {
-  // Import here to avoid circular dependency
-  const { env } = require('./env')
-  return env.NODE_ENV === 'production'
+  // Lazy import to avoid circular dependency during module initialization
+  const { appConfig } = require('@/config/app.config')
+  return appConfig.env === 'production'
 }
 
 export const isDevelopment = (): boolean => {
-  // Import here to avoid circular dependency
-  const { env } = require('./env')
-  return env.NODE_ENV === 'development' || !env.NODE_ENV
+  // Lazy import to avoid circular dependency during module initialization
+  const { appConfig } = require('@/config/app.config')
+  return appConfig.env === 'development'
 }
 
 export const isTest = (): boolean => {
-  // Import here to avoid circular dependency
-  const { env } = require('./env')
-  return env.NODE_ENV === 'test'
+  // Lazy import to avoid circular dependency during module initialization
+  const { appConfig } = require('@/config/app.config')
+  return appConfig.env === 'test'
 }
 
 export const deepMerge = <T extends Record<string, any>>(target: T, source: Partial<T>): T => {

package/core/utils/logger/startup-banner.ts

@@ -33,43 +33,17 @@ export function displayStartupBanner(info: StartupInfo): void {
     pluginCount = 0,
     vitePort,
     viteEmbedded = false,
-    swaggerPath
   } = info
 
-  console.log('\n' + chalk.cyan.bold('⚡ FluxStack') + chalk.gray(` v${FLUXSTACK_VERSION}\n`))
-
-  // Server info
-  console.log(chalk.bold('🚀 Server'))
-  console.log(`   ${chalk.gray('→')} http://localhost:${port}`)
-  console.log(`   ${chalk.gray('→')} API: http://localhost:${port}${apiPrefix}`)
-  console.log(`   ${chalk.gray('→')} Health: http://localhost:${port}${apiPrefix}/health`)
-
-  // Frontend info (only if Vite is running standalone, NOT embedded)
-  if (vitePort && !viteEmbedded) {
-    console.log('')
-    console.log(chalk.bold('⚛️  Frontend'))
-    console.log(`   ${chalk.gray('→')} http://localhost:${vitePort}`)
-  }
-
-  // Swagger docs (if enabled)
-  if (swaggerPath) {
-    console.log('')
-    console.log(chalk.bold('📋 Documentation'))
-    console.log(`   ${chalk.gray('→')} Swagger: http://localhost:${port}${swaggerPath}`)
-  }
-
-  // Environment and plugins
-  console.log('')
-  console.log(chalk.bold('ℹ️  Info'))
-  console.log(`   ${chalk.gray('→')} Environment: ${chalk.green(environment)}`)
-  console.log(`   ${chalk.gray('→')} Plugins: ${chalk.yellow(pluginCount)}`)
-
-  // Show Vite embedded status when applicable
-  if (viteEmbedded && vitePort) {
-    console.log(`   ${chalk.gray('→')} Vite: ${chalk.magenta('embedded')} ${chalk.gray(`(port ${vitePort})`)}`)
+  // Display plugins in compact format
+  const plugins = (global as any).__fluxstackPlugins || []
+  if (plugins.length > 0) {
+    const pluginList = plugins.map((p: any) => `${p.name} (${p.details})`).join(', ')
+    console.log(`Plugins (${plugins.length}): ${pluginList}\n`)
   }
 
-  console.log('\n' + chalk.green('✨ Ready!') + chalk.gray(' Press Ctrl+C to stop\n'))
+  // Simple ready message
+  console.log(chalk.green('Server ready!') + chalk.gray(` Environment: ${environment}${viteEmbedded ? ' | Vite: embedded' : ''}\n`))
 }
 
 /**

package/core/utils/regenerate-files.ts

@@ -0,0 +1,69 @@
+/**
+ * File Regeneration Utilities
+ *
+ * Provides functions to regenerate critical application files that might be
+ * accidentally deleted by developers.
+ */
+
+import { join } from "path"
+import { existsSync } from "fs"
+
+const BACKEND_ONLY_TEMPLATE = `/**
+ * Backend Standalone Entry Point
+ *
+ * This is a minimal wrapper for starting the backend in standalone mode.
+ * The core logic is protected in @/core/server/backend-entry.ts
+ *
+ * You can customize the configuration here if needed.
+ */
+
+import { startBackend, createBackendConfig } from "@/core/server/backend-entry"
+import { apiRoutes } from "./routes"
+import { serverConfig } from "@/config/server.config"
+
+// Create backend configuration from declarative config
+const backendConfig = createBackendConfig(serverConfig)
+
+// Start backend in standalone mode
+startBackend(apiRoutes, backendConfig)
+`
+
+/**
+ * Check if backend-only.ts exists, regenerate if missing
+ */
+export async function ensureBackendEntry(projectRoot: string = process.cwd()): Promise<boolean> {
+  const backendOnlyPath = join(projectRoot, "app/server/backend-only.ts")
+
+  if (!existsSync(backendOnlyPath)) {
+    console.log("⚠️  backend-only.ts not found, regenerating...")
+
+    try {
+      await Bun.write(backendOnlyPath, BACKEND_ONLY_TEMPLATE)
+      console.log("✅ backend-only.ts regenerated successfully")
+      return true
+    } catch (error) {
+      console.error("❌ Failed to regenerate backend-only.ts:", error)
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * Regenerate backend-only.ts file
+ */
+export async function regenerateBackendEntry(projectRoot: string = process.cwd()): Promise<boolean> {
+  const backendOnlyPath = join(projectRoot, "app/server/backend-only.ts")
+
+  console.log("🔄 Regenerating backend-only.ts...")
+
+  try {
+    await Bun.write(backendOnlyPath, BACKEND_ONLY_TEMPLATE)
+    console.log("✅ backend-only.ts regenerated successfully")
+    return true
+  } catch (error) {
+    console.error("❌ Failed to regenerate backend-only.ts:", error)
+    return false
+  }
+}

package/core/utils/version.ts

@@ -1,6 +1,6 @@
-/**
- * FluxStack Framework Version
- * Single source of truth for version number
- * Auto-synced with package.json
- */
-export const FLUXSTACK_VERSION = '1.7.5'
+/**
+ * FluxStack Framework Version
+ * Single source of truth for version number
+ * Auto-synced with package.json
+ */
+export const FLUXSTACK_VERSION = '1.8.3'

package/create-fluxstack.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 
 import { program } from 'commander'
-import { resolve, join } from 'path'
-import { existsSync, mkdirSync, cpSync, writeFileSync, readFileSync } from 'fs'
+import { resolve, join, basename } from 'path'
+import { existsSync, mkdirSync, cpSync, writeFileSync, readFileSync, readdirSync } from 'fs'
 import chalk from 'chalk'
 import ora from 'ora'
 import { FLUXSTACK_VERSION } from './core/utils/version'
@@ -28,30 +28,62 @@ program
   .action(async (projectName, options) => {
     console.clear()
     console.log(chalk.magenta(logo))
-    
+
     if (!projectName || projectName.trim().length === 0) {
       console.log(chalk.red('❌ Project name is required'))
-      console.log(chalk.gray('Usage: ./create-fluxstack.ts my-app'))
+      console.log(chalk.gray('Usage: bunx create-fluxstack@latest my-app'))
+      console.log(chalk.gray('   or: bunx create-fluxstack@latest .'))
       process.exit(1)
     }
-    
+
     const currentDir = import.meta.dir
-    const projectPath = resolve(projectName)
-    
-    // Check if directory already exists
-    if (existsSync(projectPath)) {
+
+    // Normalize path: remove trailing slashes (which may indicate current dir usage like path/.)
+    let normalizedName = projectName
+    const hasTrailingSlash = normalizedName.endsWith('/') || normalizedName.endsWith('\\')
+
+    if (hasTrailingSlash) {
+      normalizedName = normalizedName.slice(0, -1)
+    }
+
+    // Check if it's current directory
+    // - Explicit '.'
+    // - Path ending with /. or \. (e.g., /path/to/dir/.)
+    // - Path ending with / or \ (Bun normalizes path/. to path/)
+    const isCurrentDir = normalizedName === '.' ||
+                         projectName.endsWith('/.') ||
+                         projectName.endsWith('\\.') ||
+                         hasTrailingSlash
+
+    const projectPath = resolve(normalizedName)
+    const displayName = isCurrentDir ? 'current directory' : projectName
+
+    // Check if directory already exists (skip for current dir)
+    if (!isCurrentDir && existsSync(projectPath)) {
       console.log(chalk.red(`❌ Directory ${projectName} already exists`))
       process.exit(1)
     }
-    
-    console.log(chalk.cyan(`\n🚀 Creating FluxStack project: ${chalk.bold(projectName)}`))
+
+    // Check if current directory is not empty (when using '.')
+    if (isCurrentDir) {
+      const files = readdirSync(projectPath).filter(f => !f.startsWith('.'))
+      if (files.length > 0) {
+        console.log(chalk.yellow('⚠️  Current directory is not empty'))
+        console.log(chalk.gray(`Found ${files.length} file(s). FluxStack will be initialized here.`))
+      }
+    }
+
+    console.log(chalk.cyan(`\n🚀 Creating FluxStack project: ${chalk.bold(displayName)}`))
     console.log(chalk.gray(`📁 Location: ${projectPath}`))
     
     // Create project directory
     const spinner = ora('Creating project structure...').start()
-    
+
     try {
-      mkdirSync(projectPath, { recursive: true })
+      // Only create directory if not using current directory
+      if (!isCurrentDir) {
+        mkdirSync(projectPath, { recursive: true })
+      }
       
       // Copy only essential FluxStack files (not node_modules, not test apps, etc.)
       const frameworkDir = currentDir // Use current directory (framework root)
@@ -142,7 +174,14 @@ export class MyPlugin implements FluxStackPlugin {
   // Intercept every request
   async onRequest(context: PluginContext, request: Request): Promise<void> {
     // Example: Add custom headers
-    const url = new URL(request.url)
+    const url = (() => {
+      try {
+        return new URL(request.url)
+      } catch {
+        const host = request.headers.get('host') || 'localhost'
+        return new URL(request.url, \`http://\${host}\`)
+      }
+    })()
     console.log(\`[\${this.name}] Request to: \${url.pathname}\`)
 
     // Example: Validate authentication
@@ -305,18 +344,20 @@ bun.lockb
       
       // Customize package.json with project name
       const packageJsonPath = join(projectPath, 'package.json')
+      const actualProjectName = isCurrentDir ? basename(projectPath) : normalizedName
+
       if (existsSync(packageJsonPath)) {
         const packageContent = readFileSync(packageJsonPath, 'utf-8')
         const packageJson = JSON.parse(packageContent)
-        
+
         // Update project-specific fields
-        packageJson.name = projectName
-        packageJson.description = `${projectName} - FluxStack application`
+        packageJson.name = actualProjectName
+        packageJson.description = `${actualProjectName} - FluxStack application`
         packageJson.version = "1.0.0"
-        
+
         writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
       }
-      
+
       // Create .env from .env.example and set development mode + project name
       const envExamplePath = join(projectPath, '.env.example')
       const envPath = join(projectPath, '.env')
@@ -325,14 +366,14 @@ bun.lockb
         // Set development mode
         envContent = envContent.replace('NODE_ENV=production', 'NODE_ENV=development')
         // Customize app name to match project name
-        envContent = envContent.replace('VITE_APP_NAME=FluxStack', `VITE_APP_NAME=${projectName}`)
+        envContent = envContent.replace('VITE_APP_NAME=FluxStack', `VITE_APP_NAME=${actualProjectName}`)
         writeFileSync(envPath, envContent)
       }
-      
+
       // Customize README.md
       const readmePath = join(projectPath, 'README.md')
       if (existsSync(readmePath)) {
-        const readmeContent = `# ${projectName}
+        const readmeContent = `# ${actualProjectName}
 
 ⚡ **FluxStack Application** - Modern full-stack TypeScript framework
 
@@ -352,7 +393,7 @@ bun run start
 ## 📁 Project Structure
 
 \`\`\`
-${projectName}/
+${actualProjectName}/
 ├── core/          # FluxStack framework (don't modify)
 ├── app/           # Your application code
 │   ├── server/    # Backend API routes
@@ -471,7 +512,7 @@ Built with ❤️ using FluxStack
           })
           await addProc.exited
           
-          const commitProc = Bun.spawn(['git', 'commit', '-m', `feat: initial ${projectName} with FluxStack`], {
+          const commitProc = Bun.spawn(['git', 'commit', '-m', `feat: initial ${actualProjectName} with FluxStack`], {
             cwd: projectPath,
             stdio: ['ignore', 'pipe', 'pipe']
           })
@@ -487,7 +528,9 @@ Built with ❤️ using FluxStack
       // Success message
       console.log(chalk.green('\n🎉 Project created successfully!'))
       console.log(chalk.cyan('\nNext steps:'))
-      console.log(chalk.white(`  cd ${projectName}`))
+      if (!isCurrentDir) {
+        console.log(chalk.white(`  cd ${projectName}`))
+      }
       if (!options.install) {
         console.log(chalk.white(`  bun install`))
       }