@nextsparkjs/core 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/bin/wizard/generators/demo-installer.ts

@@ -0,0 +1,200 @@
+/**
+ * Demo Theme Installer
+ *
+ * Installs the default demo theme to allow users to explore NextSpark features.
+ * Searches for the theme in multiple locations and copies it to the project.
+ */
+
+import fs from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import chalk from 'chalk'
+import ora from 'ora'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+/**
+ * Possible locations for the default demo theme
+ */
+const DEMO_THEME_PATHS = [
+  // Relative to compiled location: bin/dist/wizard/generators/demo-installer.js
+  path.resolve(__dirname, '../../../../templates/contents/themes/default'),
+  // Alternative location in contents
+  path.resolve(__dirname, '../../../../contents/themes/default'),
+]
+
+/**
+ * Get the target themes directory in the user's project
+ */
+function getTargetThemesDir(): string {
+  return path.resolve(process.cwd(), 'contents', 'themes')
+}
+
+/**
+ * Find the demo theme source directory
+ */
+async function findDemoTheme(): Promise<string | null> {
+  for (const themePath of DEMO_THEME_PATHS) {
+    if (await fs.pathExists(themePath)) {
+      return themePath
+    }
+  }
+  return null
+}
+
+/**
+ * Possible locations for the langchain plugin
+ */
+const LANGCHAIN_PLUGIN_PATHS = [
+  // Relative to compiled location: bin/dist/wizard/generators/demo-installer.js
+  path.resolve(__dirname, '../../../../templates/contents/plugins/langchain'),
+  // Alternative location in contents
+  path.resolve(__dirname, '../../../../contents/plugins/langchain'),
+]
+
+/**
+ * Copy langchain plugin files to user's project
+ */
+async function copyLangchainPlugin(): Promise<void> {
+  // Find the plugin source
+  let pluginSource: string | null = null
+  for (const pluginPath of LANGCHAIN_PLUGIN_PATHS) {
+    if (await fs.pathExists(pluginPath)) {
+      pluginSource = pluginPath
+      break
+    }
+  }
+
+  if (!pluginSource) {
+    // Plugin not found, skip silently
+    return
+  }
+
+  const pluginTarget = path.resolve(process.cwd(), 'contents', 'plugins', 'langchain')
+
+  // Skip if already exists
+  if (await fs.pathExists(pluginTarget)) {
+    return
+  }
+
+  // Ensure parent directory exists and copy
+  await fs.ensureDir(path.dirname(pluginTarget))
+  await fs.copy(pluginSource, pluginTarget)
+}
+
+/**
+ * Update theme.config.ts to enable the langchain plugin
+ */
+async function enableLangchainPlugin(themePath: string): Promise<void> {
+  const themeConfigPath = path.join(themePath, 'config', 'theme.config.ts')
+
+  if (!await fs.pathExists(themeConfigPath)) {
+    // Config file doesn't exist, skip modification
+    return
+  }
+
+  let content = await fs.readFile(themeConfigPath, 'utf-8')
+
+  // Check if plugins array exists
+  if (content.includes('plugins:')) {
+    // Check if langchain is already in plugins
+    if (!content.includes("'langchain'") && !content.includes('"langchain"')) {
+      // Add langchain to existing plugins array
+      content = content.replace(
+        /plugins:\s*\[(.*?)\]/s,
+        (match, plugins) => {
+          const existingPlugins = plugins.trim()
+          if (existingPlugins) {
+            return `plugins: [${existingPlugins}, 'langchain']`
+          }
+          return `plugins: ['langchain']`
+        }
+      )
+    }
+  } else {
+    // No plugins array exists, add it after description
+    content = content.replace(
+      /(description:\s*['"].*?['"],?\n)/,
+      "$1\n  plugins: ['langchain'],\n"
+    )
+  }
+
+  await fs.writeFile(themeConfigPath, content, 'utf-8')
+}
+
+/**
+ * Install the demo theme to the user's project
+ *
+ * @returns true if installation was successful, false otherwise
+ */
+export async function installDemoTheme(): Promise<boolean> {
+  const spinner = ora({
+    text: 'Searching for demo theme...',
+    prefixText: '  ',
+  }).start()
+
+  try {
+    // Find the demo theme source
+    const demoThemePath = await findDemoTheme()
+
+    if (!demoThemePath) {
+      spinner.fail(chalk.red('Demo theme not found'))
+      console.log(chalk.gray('  Searched locations:'))
+      for (const searchPath of DEMO_THEME_PATHS) {
+        console.log(chalk.gray(`    - ${searchPath}`))
+      }
+      return false
+    }
+
+    spinner.text = 'Preparing installation directory...'
+
+    // Prepare target directory
+    const targetThemesDir = getTargetThemesDir()
+    const targetDemoPath = path.join(targetThemesDir, 'default')
+
+    // Check if demo theme already exists
+    if (await fs.pathExists(targetDemoPath)) {
+      spinner.warn(chalk.yellow('Demo theme already exists at: contents/themes/default'))
+      console.log(chalk.gray('  Skipping installation to avoid overwriting existing files.'))
+      return true
+    }
+
+    // Ensure themes directory exists
+    await fs.ensureDir(targetThemesDir)
+
+    spinner.text = 'Copying demo theme files...'
+
+    // Copy the entire demo theme
+    await fs.copy(demoThemePath, targetDemoPath)
+
+    spinner.text = 'Configuring demo theme...'
+
+    // Enable langchain plugin in theme config
+    await enableLangchainPlugin(targetDemoPath)
+
+    // Copy langchain plugin files
+    await copyLangchainPlugin()
+
+    spinner.succeed(chalk.green('Demo theme installed successfully!'))
+
+    // Show installation details
+    console.log('')
+    console.log(chalk.gray('  Demo theme location: ') + chalk.cyan('contents/themes/default/'))
+    console.log(chalk.gray('  Enabled plugin: ') + chalk.cyan('langchain'))
+    console.log('')
+    console.log(chalk.yellow('  Remember: This is a demo for exploration only.'))
+    console.log(chalk.yellow('  Complete the wizard to create your customized project.'))
+    console.log('')
+
+    return true
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to install demo theme'))
+
+    if (error instanceof Error) {
+      console.log(chalk.red(`  Error: ${error.message}`))
+    }
+
+    return false
+  }
+}

package/dist/bin/wizard/generators/env-setup.ts

@@ -0,0 +1,208 @@
+/**
+ * Environment Setup Generator
+ *
+ * Generates and configures the .env file based on wizard responses.
+ */
+
+import crypto from 'crypto'
+import fs from 'fs-extra'
+import path from 'path'
+import type { WizardConfig } from '../types.js'
+import type { EnvSetupAnswers } from '../prompts/env-config.js'
+import { showSuccess, showInfo, showWarning } from '../banner.js'
+
+/**
+ * Generate a secure random secret
+ */
+function generateSecret(): string {
+  return crypto.randomBytes(32).toString('hex')
+}
+
+/**
+ * Setup environment configuration for the project
+ *
+ * @param projectPath - Path to the project directory
+ * @param answers - Environment setup answers from prompts
+ * @param config - Full wizard configuration
+ */
+export async function setupEnvironment(
+  projectPath: string,
+  answers: EnvSetupAnswers,
+  config: WizardConfig
+): Promise<void> {
+  if (!answers.setupEnv) {
+    showInfo('Skipping .env setup')
+    return
+  }
+
+  const envExamplePath = path.join(projectPath, '.env.example')
+  const envPath = path.join(projectPath, '.env')
+
+  // Check if .env.example exists
+  if (!await fs.pathExists(envExamplePath)) {
+    showWarning('.env.example not found, creating default .env file')
+    await createDefaultEnv(envPath, answers, config)
+    return
+  }
+
+  // Check if .env already exists
+  if (await fs.pathExists(envPath)) {
+    showWarning('.env already exists, updating existing file')
+    await updateExistingEnv(envPath, answers, config)
+    return
+  }
+
+  // Copy .env.example to .env
+  await fs.copy(envExamplePath, envPath)
+  showSuccess('Copied .env.example to .env')
+
+  // Update the .env file with wizard values
+  await updateEnvFile(envPath, answers, config)
+}
+
+/**
+ * Update an existing .env file with new values
+ */
+async function updateExistingEnv(
+  envPath: string,
+  answers: EnvSetupAnswers,
+  config: WizardConfig
+): Promise<void> {
+  let content = await fs.readFile(envPath, 'utf-8')
+
+  // Update NEXT_PUBLIC_ACTIVE_THEME
+  content = updateEnvVar(content, 'NEXT_PUBLIC_ACTIVE_THEME', config.projectSlug)
+  showSuccess(`Set NEXT_PUBLIC_ACTIVE_THEME=${config.projectSlug}`)
+
+  // Generate and set secrets if requested
+  if (answers.generateSecrets) {
+    const authSecret = generateSecret()
+    const encryptionKey = generateSecret()
+
+    content = updateEnvVar(content, 'AUTH_SECRET', authSecret)
+    content = updateEnvVar(content, 'BETTER_AUTH_SECRET', authSecret)
+    content = updateEnvVar(content, 'ENCRYPTION_KEY', encryptionKey)
+
+    showSuccess('Generated secure AUTH_SECRET')
+    showSuccess('Generated secure ENCRYPTION_KEY')
+  }
+
+  // Set DATABASE_URL if provided
+  if (answers.databaseUrl) {
+    content = updateEnvVar(content, 'DATABASE_URL', answers.databaseUrl)
+    showSuccess('Set DATABASE_URL')
+  }
+
+  await fs.writeFile(envPath, content, 'utf-8')
+}
+
+/**
+ * Update the .env file with wizard configuration values
+ */
+async function updateEnvFile(
+  envPath: string,
+  answers: EnvSetupAnswers,
+  config: WizardConfig
+): Promise<void> {
+  let content = await fs.readFile(envPath, 'utf-8')
+
+  // Update NEXT_PUBLIC_ACTIVE_THEME with project slug
+  content = updateEnvVar(content, 'NEXT_PUBLIC_ACTIVE_THEME', config.projectSlug)
+  showSuccess(`Set NEXT_PUBLIC_ACTIVE_THEME=${config.projectSlug}`)
+
+  // Generate and set secrets if requested
+  if (answers.generateSecrets) {
+    const authSecret = generateSecret()
+    const encryptionKey = generateSecret()
+
+    // Try to update AUTH_SECRET or BETTER_AUTH_SECRET (depending on what's in the file)
+    content = updateEnvVar(content, 'AUTH_SECRET', authSecret)
+    content = updateEnvVar(content, 'BETTER_AUTH_SECRET', authSecret)
+    content = updateEnvVar(content, 'ENCRYPTION_KEY', encryptionKey)
+
+    showSuccess('Generated secure AUTH_SECRET')
+    showSuccess('Generated secure ENCRYPTION_KEY')
+  }
+
+  // Set DATABASE_URL if provided
+  if (answers.databaseUrl) {
+    content = updateEnvVar(content, 'DATABASE_URL', answers.databaseUrl)
+    showSuccess('Set DATABASE_URL')
+  }
+
+  await fs.writeFile(envPath, content, 'utf-8')
+}
+
+/**
+ * Update or add an environment variable in content
+ */
+function updateEnvVar(content: string, key: string, value: string): string {
+  // Pattern to match the env var (with or without quotes, commented or not)
+  const pattern = new RegExp(`^(#?\\s*${key}\\s*=).*$`, 'm')
+
+  if (pattern.test(content)) {
+    // Update existing variable
+    return content.replace(pattern, `${key}=${value}`)
+  } else {
+    // Add new variable at the end
+    return content.trimEnd() + `\n${key}=${value}\n`
+  }
+}
+
+/**
+ * Create a default .env file when .env.example doesn't exist
+ */
+async function createDefaultEnv(
+  envPath: string,
+  answers: EnvSetupAnswers,
+  config: WizardConfig
+): Promise<void> {
+  const authSecret = answers.generateSecrets ? generateSecret() : 'your-secret-key-min-32-chars'
+  const encryptionKey = answers.generateSecrets ? generateSecret() : 'your-encryption-key-min-32-chars'
+  const databaseUrl = answers.databaseUrl || 'postgresql://user:password@localhost:5432/nextspark'
+
+  const content = `# NextSpark Environment Configuration
+# Generated by NextSpark Wizard for: ${config.projectName}
+
+# Database
+DATABASE_URL=${databaseUrl}
+
+# Authentication (Better Auth)
+AUTH_SECRET=${authSecret}
+BETTER_AUTH_SECRET=${authSecret}
+
+# Encryption
+ENCRYPTION_KEY=${encryptionKey}
+
+# App URL
+NEXT_PUBLIC_APP_URL=http://localhost:3000
+
+# Active Theme
+NEXT_PUBLIC_ACTIVE_THEME=${config.projectSlug}
+
+# Email (Resend) - Optional
+RESEND_API_KEY=
+RESEND_FROM_EMAIL=
+
+# Google OAuth - Optional
+GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_SECRET=
+
+# Stripe - Optional
+STRIPE_SECRET_KEY=
+STRIPE_WEBHOOK_SECRET=
+NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=
+`
+
+  await fs.writeFile(envPath, content, 'utf-8')
+  showSuccess('Created .env file with default configuration')
+
+  if (answers.generateSecrets) {
+    showSuccess('Generated secure AUTH_SECRET')
+    showSuccess('Generated secure ENCRYPTION_KEY')
+  }
+
+  if (answers.databaseUrl) {
+    showSuccess('Set DATABASE_URL')
+  }
+}

package/dist/bin/wizard/generators/git-init.ts

@@ -0,0 +1,187 @@
+/**
+ * Git Initialization Generator
+ *
+ * Handles Git repository initialization, .gitignore creation, and initial commit.
+ */
+
+import { execSync } from 'child_process'
+import fs from 'fs-extra'
+import path from 'path'
+import type { GitSetupAnswers } from '../prompts/git-config.js'
+import type { WizardConfig } from '../types.js'
+
+/**
+ * NextSpark .gitignore content
+ */
+const GITIGNORE_CONTENT = `# Dependencies
+node_modules/
+
+# Next.js
+.next/
+out/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Build
+dist/
+build/
+
+# Turbo
+.turbo/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Testing
+coverage/
+.nyc_output/
+
+# NextSpark
+.nextspark/
+`
+
+/**
+ * Check if Git is installed and available
+ */
+function isGitAvailable(): boolean {
+  try {
+    execSync('git --version', { stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Check if the directory is already a Git repository
+ */
+async function isGitRepository(projectPath: string): Promise<boolean> {
+  const gitDir = path.join(projectPath, '.git')
+  return fs.pathExists(gitDir)
+}
+
+/**
+ * Initialize a new Git repository
+ */
+function initGitRepository(projectPath: string): void {
+  execSync('git init', {
+    cwd: projectPath,
+    stdio: 'pipe',
+  })
+}
+
+/**
+ * Create or update .gitignore file
+ */
+async function createGitignore(projectPath: string): Promise<void> {
+  const gitignorePath = path.join(projectPath, '.gitignore')
+
+  if (await fs.pathExists(gitignorePath)) {
+    // Append NextSpark entries if not already present
+    const currentContent = await fs.readFile(gitignorePath, 'utf-8')
+    if (!currentContent.includes('.nextspark/')) {
+      const separator = currentContent.endsWith('\n') ? '' : '\n'
+      await fs.appendFile(gitignorePath, `${separator}\n# NextSpark additions\n.nextspark/\n`)
+    }
+  } else {
+    // Create new .gitignore
+    await fs.writeFile(gitignorePath, GITIGNORE_CONTENT)
+  }
+}
+
+/**
+ * Stage all files and create initial commit
+ */
+function createInitialCommit(projectPath: string, message: string): void {
+  execSync('git add .', {
+    cwd: projectPath,
+    stdio: 'pipe',
+  })
+
+  execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, {
+    cwd: projectPath,
+    stdio: 'pipe',
+  })
+}
+
+/**
+ * Setup Git repository based on user preferences
+ *
+ * @param projectPath - Path to the project directory
+ * @param answers - User's git setup preferences
+ * @param config - Wizard configuration (for future extensibility)
+ */
+export async function setupGit(
+  projectPath: string,
+  answers: GitSetupAnswers,
+  config: WizardConfig
+): Promise<void> {
+  // If user doesn't want git, skip everything
+  if (!answers.initGit) {
+    return
+  }
+
+  // Check if Git is available
+  if (!isGitAvailable()) {
+    console.warn('\n  Warning: Git is not installed or not available in PATH.')
+    console.warn('  Skipping Git initialization.\n')
+    return
+  }
+
+  try {
+    // Check if already a Git repository
+    const isExistingRepo = await isGitRepository(projectPath)
+
+    if (!isExistingRepo) {
+      // Initialize new Git repository
+      initGitRepository(projectPath)
+      console.log('  Initialized Git repository.')
+    } else {
+      console.log('  Git repository already exists, skipping init.')
+    }
+
+    // Create or update .gitignore
+    await createGitignore(projectPath)
+    console.log('  Created .gitignore file.')
+
+    // Create initial commit if requested
+    if (answers.createCommit && answers.commitMessage) {
+      try {
+        createInitialCommit(projectPath, answers.commitMessage)
+        console.log(`  Created initial commit: "${answers.commitMessage}"`)
+      } catch (commitError) {
+        // Commit might fail if there's nothing to commit or git user not configured
+        const errorMessage = commitError instanceof Error ? commitError.message : String(commitError)
+        if (errorMessage.includes('nothing to commit')) {
+          console.log('  No changes to commit.')
+        } else if (errorMessage.includes('user.email') || errorMessage.includes('user.name')) {
+          console.warn('\n  Warning: Git user not configured.')
+          console.warn('  Run: git config --global user.name "Your Name"')
+          console.warn('  Run: git config --global user.email "your@email.com"\n')
+        } else {
+          console.warn(`\n  Warning: Could not create commit: ${errorMessage}\n`)
+        }
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    console.warn(`\n  Warning: Git setup failed: ${errorMessage}`)
+    console.warn('  You can initialize Git manually later.\n')
+  }
+}