create-propelkit 1.0.0

package/src/design-flow.js

@@ -0,0 +1,442 @@
+/**
+ * Design Flow Orchestrator
+ *
+ * Multi-turn conversation flow for collecting design decisions.
+ * Handles 4 paths: Lovable, Existing, Manual, Skip
+ */
+
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { spawn } = require('child_process');
+const { validateHexColor } = require('./validators');
+const { derivePages } = require('./page-mapper');
+const { generateLovablePrompt } = require('./prompt-generator');
+
+/**
+ * Parse features from project's src/config/features.ts
+ * @param {string} projectDir - Path to the project directory
+ * @returns {{ multiTenancy: boolean, credits: boolean }}
+ */
+function parseFeaturesFile(projectDir) {
+  const featuresPath = path.join(projectDir, 'src', 'config', 'features.ts');
+
+  // Default features if file doesn't exist
+  const defaults = { multiTenancy: false, credits: false };
+
+  if (!fs.existsSync(featuresPath)) {
+    return defaults;
+  }
+
+  const content = fs.readFileSync(featuresPath, 'utf-8');
+  const features = { ...defaults };
+
+  // Parse multiTenancy: true/false
+  const multiTenancyMatch = content.match(/multiTenancy:\s*(true|false)/);
+  if (multiTenancyMatch) {
+    features.multiTenancy = multiTenancyMatch[1] === 'true';
+  }
+
+  // Parse credits: true/false
+  const creditsMatch = content.match(/credits:\s*(true|false)/);
+  if (creditsMatch) {
+    features.credits = creditsMatch[1] === 'true';
+  }
+
+  return features;
+}
+
+/**
+ * Ask user for design approach choice
+ * @returns {Promise<'lovable' | 'existing' | 'manual' | 'skip'>}
+ */
+async function askDesignApproach() {
+  const { approach } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'approach',
+      message: 'How would you like to handle UI design?',
+      choices: [
+        {
+          name: 'Generate with Lovable - Create beautiful UI with AI',
+          value: 'lovable'
+        },
+        {
+          name: 'I have existing designs - Import from GitHub/local',
+          value: 'existing'
+        },
+        {
+          name: 'Manual/code-first - I\'ll build UI myself',
+          value: 'manual'
+        },
+        {
+          name: 'Skip for now - Defer design decision',
+          value: 'skip'
+        }
+      ]
+    }
+  ]);
+
+  return approach;
+}
+
+/**
+ * Collect design system inputs from user
+ * @returns {Promise<{ primaryColor: string, accentColor: string, styleReference: string, brandVoice: string }>}
+ */
+async function askDesignSystem() {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'primaryColor',
+      message: 'Primary brand color (hex):',
+      default: '#3B82F6',
+      validate: (input) => {
+        const result = validateHexColor(input);
+        return result.success || result.error;
+      }
+    },
+    {
+      type: 'input',
+      name: 'accentColor',
+      message: 'Accent color (hex):',
+      default: '#10B981',
+      validate: (input) => {
+        const result = validateHexColor(input);
+        return result.success || result.error;
+      }
+    },
+    {
+      type: 'list',
+      name: 'styleReference',
+      message: 'Style reference:',
+      choices: [
+        { name: 'Linear - Minimal, dark mode friendly, clean typography', value: 'linear' },
+        { name: 'Notion - Friendly, content-focused, approachable', value: 'notion' },
+        { name: 'Stripe - Professional, elegant, trustworthy', value: 'stripe' },
+        { name: 'Vercel - Modern, geometric, developer-focused', value: 'vercel' },
+        { name: 'Airbnb - Warm, inviting, human-centered', value: 'airbnb' }
+      ]
+    },
+    {
+      type: 'list',
+      name: 'brandVoice',
+      message: 'Brand voice:',
+      choices: [
+        { name: 'Professional - Formal, authoritative, expert', value: 'Professional' },
+        { name: 'Friendly - Conversational, helpful, approachable', value: 'Friendly' },
+        { name: 'Bold - Confident, direct, impactful', value: 'Bold' },
+        { name: 'Playful - Fun, light-hearted, creative', value: 'Playful' }
+      ]
+    }
+  ]);
+
+  return answers;
+}
+
+/**
+ * Confirm derived pages and allow additions
+ * @param {string[]} derivedPages - Pages derived from features
+ * @returns {Promise<string[]>} - Final page list
+ */
+async function confirmPages(derivedPages) {
+  // Let user select which pages to include
+  const { selectedPages } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedPages',
+      message: 'Select pages to include:',
+      choices: derivedPages.map(page => ({
+        name: page,
+        value: page,
+        checked: true
+      })),
+      pageSize: 15
+    }
+  ]);
+
+  // Ask for custom pages
+  const { customPages } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'customPages',
+      message: 'Add custom pages (comma-separated, or press Enter to skip):',
+      default: ''
+    }
+  ]);
+
+  // Parse custom pages
+  const additionalPages = customPages
+    .split(',')
+    .map(p => p.trim())
+    .filter(p => p.length > 0);
+
+  // Combine and deduplicate
+  const allPages = [...new Set([...selectedPages, ...additionalPages])];
+
+  return allPages.sort();
+}
+
+/**
+ * Handle Lovable design approach
+ * @param {string} projectName - Name of the project
+ * @param {string} projectDir - Path to project directory
+ * @returns {Promise<{ approach: 'lovable', promptPath: string }>}
+ */
+async function handleLovablePath(projectName, projectDir) {
+  console.log('');
+  console.log(chalk.cyan('Collecting design preferences...'));
+  console.log('');
+
+  // Get design system inputs
+  const designSystem = await askDesignSystem();
+
+  // Parse features from project
+  const features = parseFeaturesFile(projectDir);
+
+  // Derive pages based on features
+  const derivedPages = derivePages(features);
+
+  console.log('');
+  console.log(chalk.cyan('Based on your features, these pages are suggested:'));
+  console.log('');
+
+  // Confirm pages
+  const finalPages = await confirmPages(derivedPages);
+
+  // Generate Lovable prompt
+  const prompt = generateLovablePrompt(designSystem, finalPages, projectName);
+
+  // Write to LOVABLE_PROMPT.md
+  const promptPath = path.join(projectDir, 'LOVABLE_PROMPT.md');
+  fs.writeFileSync(promptPath, prompt, 'utf-8');
+
+  // Success message
+  console.log('');
+  console.log(chalk.green.bold('Lovable prompt generated!'));
+  console.log('');
+  console.log(chalk.dim('Saved to:'), chalk.white(promptPath));
+  console.log('');
+  console.log(chalk.cyan('Next steps:'));
+  console.log(chalk.dim('  1. Open lovable.dev and create a new project'));
+  console.log(chalk.dim('  2. Copy the contents of LOVABLE_PROMPT.md'));
+  console.log(chalk.dim('  3. Paste into Lovable and generate your UI'));
+  console.log(chalk.dim('  4. Export from Lovable and use /propelkit:import'));
+  console.log('');
+
+  return {
+    approach: 'lovable',
+    promptPath,
+    designSystem,
+    pages: finalPages
+  };
+}
+
+/**
+ * Spawn TypeScript orchestrator to execute import → translation → integration.
+ *
+ * @param {string} projectDir - Target project directory
+ * @param {object} source - Import source ({ type: 'github'|'local', url?, path? })
+ * @returns {Promise<{ approach: 'existing', source: object }>}
+ */
+function spawnOrchestrator(projectDir, source) {
+  const orchestratorPath = path.join(__dirname, 'orchestrators', 'existing-designs.ts');
+  const sourceJson = Buffer.from(JSON.stringify(source)).toString('base64');
+  const monorepoRoot = path.resolve(__dirname, '../../..');
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      'npx',
+      ['tsx', orchestratorPath, '--project-dir', projectDir, '--source-base64', sourceJson],
+      {
+        stdio: 'inherit',  // User sees orchestrator's console.log
+        shell: true,       // Windows compatibility
+        cwd: monorepoRoot  // Run from root for tsconfig path resolution
+      }
+    );
+
+    child.on('error', (err) => {
+      console.error('');
+      console.error(chalk.red('Failed to start import pipeline'));
+      console.error(chalk.dim(`Error: ${err.message}`));
+      console.error('');
+      reject(err);
+    });
+
+    child.on('exit', (code) => {
+      if (code === 0) {
+        console.log('');
+        console.log(chalk.green.bold('✓ Import pipeline completed successfully!'));
+        console.log('');
+        resolve({ approach: 'existing', source });
+      } else {
+        console.error('');
+        console.error(chalk.red(`✗ Import pipeline failed (exit code ${code})`));
+        console.error('');
+        reject(new Error(`Pipeline failed with exit code ${code}`));
+      }
+    });
+  });
+}
+
+/**
+ * Handle existing designs import approach
+ * @param {string} projectDir - Path to project directory
+ * @returns {Promise<{ approach: 'existing', source: { type: 'github' | 'local', url?: string, path?: string } }>}
+ */
+async function handleExistingPath(projectDir) {
+  console.log('');
+  console.log(chalk.cyan('Import existing designs into PropelKit...'));
+  console.log('');
+
+  // Ask source type
+  const { sourceType } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'sourceType',
+      message: 'Where are your designs?',
+      choices: [
+        { name: 'GitHub repository', value: 'github' },
+        { name: 'Local folder', value: 'local' }
+      ]
+    }
+  ]);
+
+  let source;
+
+  if (sourceType === 'github') {
+    const { url } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'url',
+        message: 'GitHub repository URL:',
+        validate: (input) => {
+          if (!input.includes('github.com')) {
+            return 'Please enter a valid GitHub URL';
+          }
+          return true;
+        }
+      }
+    ]);
+
+    source = { type: 'github', url };
+  } else {
+    const { localPath } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'localPath',
+        message: 'Path to local folder:',
+        validate: (input) => {
+          const resolvedPath = path.resolve(input);
+          if (!fs.existsSync(resolvedPath)) {
+            return `Path does not exist: ${resolvedPath}`;
+          }
+          return true;
+        }
+      }
+    ]);
+
+    source = { type: 'local', path: path.resolve(localPath) };
+  }
+
+  console.log('');
+  console.log(chalk.green.bold('Starting import pipeline...'));
+  console.log('');
+
+  // NEW: Spawn TypeScript orchestrator
+  return spawnOrchestrator(projectDir, source);
+}
+
+/**
+ * Handle manual/code-first approach
+ * @param {string} projectDir - Path to project directory
+ * @returns {Promise<{ approach: 'manual', suggestedPages: string[] }>}
+ */
+async function handleManualPath(projectDir) {
+  // Parse features and derive suggested pages
+  const features = parseFeaturesFile(projectDir);
+  const suggestedPages = derivePages(features);
+
+  console.log('');
+  console.log(chalk.cyan('Building UI manually? Here\'s your suggested page list:'));
+  console.log('');
+
+  suggestedPages.forEach(page => {
+    console.log(chalk.dim('  -'), chalk.white(page));
+  });
+
+  console.log('');
+  console.log(chalk.cyan('Guidance:'));
+  console.log(chalk.dim('  - Use shadcn/ui components from src/components/ui/'));
+  console.log(chalk.dim('  - Follow the PropelKit color scheme from src/config/theme.ts'));
+  console.log(chalk.dim('  - See existing pages in src/app/ for patterns'));
+  console.log(chalk.dim('  - Run /propelkit:design later if you want AI assistance'));
+  console.log('');
+
+  return {
+    approach: 'manual',
+    suggestedPages
+  };
+}
+
+/**
+ * Handle skip/defer approach
+ * @returns {{ approach: 'skip' }}
+ */
+function handleSkipPath() {
+  console.log('');
+  console.log(chalk.yellow('Design decision deferred.'));
+  console.log('');
+  console.log(chalk.dim('You can revisit this later by running:'));
+  console.log(chalk.cyan('  /propelkit:design'));
+  console.log('');
+  console.log(chalk.dim('The AI PM can also help with design at any time.'));
+  console.log('');
+
+  return {
+    approach: 'skip'
+  };
+}
+
+/**
+ * Run the complete design flow
+ * @param {string} projectName - Name of the project
+ * @param {string} projectDir - Path to project directory
+ * @returns {Promise<{ approach: string, [key: string]: any }>}
+ */
+async function runDesignFlow(projectName, projectDir) {
+  console.log('');
+  console.log(chalk.bold.blue('Design Approach'));
+  console.log(chalk.dim('Choose how you want to create your UI'));
+  console.log('');
+
+  // Get approach choice
+  const approach = await askDesignApproach();
+
+  // Route to appropriate handler
+  switch (approach) {
+    case 'lovable':
+      return handleLovablePath(projectName, projectDir);
+    case 'existing':
+      return handleExistingPath(projectDir);
+    case 'manual':
+      return handleManualPath(projectDir);
+    case 'skip':
+      return handleSkipPath();
+    default:
+      return handleSkipPath();
+  }
+}
+
+module.exports = {
+  runDesignFlow,
+  askDesignApproach,
+  askDesignSystem,
+  confirmPages,
+  handleLovablePath,
+  handleExistingPath,
+  handleManualPath,
+  handleSkipPath,
+  parseFeaturesFile
+};

package/src/index.js

@@ -0,0 +1,126 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const inquirer = require('inquirer');
+const { detectCLIs, displayCLIStatus, getCLIByName, askGitHubConnection } = require('./cli-detector');
+const { handleScenario } = require('./scenarios');
+const { runDesignFlow } = require('./design-flow');
+const { runSetupWizard } = require('./setup-wizard');
+const { launchClaude } = require('./launcher');
+const { validateLicense } = require('./license-validator');
+const messages = require('./messages');
+
+async function main() {
+  // Step 1: Welcome
+  messages.welcome();
+
+  // Step 2: LICENSE VALIDATION (first thing after welcome)
+  console.log('');
+  const { licenseKey } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'licenseKey',
+      message: 'License key:',
+      validate: input => input.trim() ? true : 'License key is required'
+    }
+  ]);
+
+  console.log(chalk.dim('Validating license...'));
+  const validation = await validateLicense(licenseKey.trim());
+
+  if (!validation.valid) {
+    messages.licenseInvalid(validation.message);
+    process.exit(1);
+  }
+
+  const tier = validation.tier; // 'starter' or 'pro'
+
+  if (tier === 'starter') {
+    messages.starterLicenseValid();
+  } else {
+    messages.proLicenseValid();
+  }
+
+  // Step 3: Detect CLIs
+  messages.detectingCLIs();
+  const clis = await detectCLIs();
+  displayCLIStatus(clis, chalk);
+
+  // Step 4: Check for Claude Code (required for PRO only)
+  const claudeCli = getCLIByName(clis, 'claude');
+  if (tier === 'pro' && !claudeCli.installed) {
+    messages.claudeRequired(claudeCli.installUrl);
+    process.exit(1);
+  }
+
+  // Step 5: Show benefits for missing optional CLIs
+  const supabaseCli = getCLIByName(clis, 'supabase');
+  const ghCli = getCLIByName(clis, 'gh');
+
+  if (!supabaseCli.installed) {
+    messages.supabaseBenefits();
+  }
+
+  if (!ghCli.installed) {
+    messages.githubBenefits();
+  }
+
+  // Step 6: GitHub connection (for Pro tier, or if user wants it for Starter)
+  const useGitHub = tier === 'pro' ? await askGitHubConnection(ghCli, chalk) : false;
+
+  // Step 7: Clone scenario (pass tier first)
+  let projectDir;
+  try {
+    projectDir = await handleScenario(tier, clis, useGitHub);
+  } catch (error) {
+    if (error.message === 'Aborted by user') {
+      console.log('');
+      console.log(chalk.dim('Goodbye!'));
+      process.exit(0);
+    }
+    throw error;
+  }
+
+  // Step 8: TIER-SPECIFIC POST-CLONE FLOW
+  if (tier === 'starter') {
+    // Starter: Run setup wizard, then done
+    await runSetupWizard(projectDir);
+    messages.starterWizardComplete();
+  } else {
+    // Pro: Run design flow, then launch Claude Code
+    console.log('');
+    const designResult = await runDesignFlow(
+      path.basename(projectDir),
+      projectDir
+    );
+
+    // Store design result in config.json
+    const configPath = path.join(projectDir, '.planning', 'config.json');
+    let config = {};
+    if (fs.existsSync(configPath)) {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+    config.designFlow = designResult;
+
+    const planningDir = path.dirname(configPath);
+    if (!fs.existsSync(planningDir)) {
+      fs.mkdirSync(planningDir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+
+    // Launch Claude Code
+    messages.proLaunchingAIPM(projectDir);
+    try {
+      await launchClaude(projectDir);
+    } catch (error) {
+      if (error.message === 'CLAUDE_NOT_FOUND') {
+        const claudeInfo = getCLIByName(clis, 'claude');
+        messages.claudeRequired(claudeInfo.installUrl);
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+}
+
+module.exports = { main };

package/src/launcher.js

@@ -0,0 +1,42 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const messages = require('./messages');
+
+/**
+ * Launch Claude Code in the specified directory
+ * @param {string} projectDir - Absolute path to project directory
+ * @param {object} options - Launch options
+ * @returns {Promise<void>}
+ */
+function launchClaude(projectDir, _options = {}) {
+  return new Promise((resolve, reject) => {
+    const resolvedDir = path.resolve(projectDir);
+
+    messages.launchingClaude(resolvedDir);
+
+    const claude = spawn('claude', [], {
+      cwd: resolvedDir,
+      stdio: 'inherit',  // User sees Claude's I/O directly
+      shell: true        // Required for Windows compatibility
+    });
+
+    claude.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        reject(new Error('CLAUDE_NOT_FOUND'));
+      } else {
+        reject(new Error(`Failed to launch Claude Code: ${err.message}`));
+      }
+    });
+
+    claude.on('exit', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        // Non-zero exit is fine - user may have quit normally
+        resolve();
+      }
+    });
+  });
+}
+
+module.exports = { launchClaude };

package/src/license-validator.js

@@ -0,0 +1,85 @@
+const https = require('https');
+const { URL } = require('url');
+const { API_ENDPOINTS, LICENSE_PATTERNS, TIMEOUTS } = require('./config');
+
+/**
+ * Validate license key against propelkit.dev API
+ * @param {string} key - License key (e.g., PK-STARTER-2026-ABC123)
+ * @returns {Promise<{valid: boolean, tier?: 'starter'|'pro', message?: string}>}
+ */
+async function validateLicense(key) {
+  // Client-side format check (quick fail for obviously invalid keys)
+  if (!LICENSE_PATTERNS.format.test(key)) {
+    return { valid: false, message: 'Invalid license key format' };
+  }
+
+  return new Promise((resolve) => {
+    const url = new URL(API_ENDPOINTS.licenseValidation);
+    const data = JSON.stringify({ licenseKey: key });
+
+    const options = {
+      hostname: url.hostname,
+      port: 443,
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(data)
+      },
+      timeout: TIMEOUTS.licenseValidation
+    };
+
+    const req = https.request(options, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try {
+          if (res.statusCode === 200) {
+            const result = JSON.parse(body);
+            resolve({
+              valid: true,
+              tier: result.tier // 'starter' or 'pro'
+            });
+          } else if (res.statusCode === 400) {
+            resolve({ valid: false, message: 'Invalid license key format' });
+          } else if (res.statusCode === 404) {
+            resolve({ valid: false, message: 'License key not found' });
+          } else if (res.statusCode === 403) {
+            resolve({ valid: false, message: 'License is not active' });
+          } else {
+            resolve({ valid: false, message: 'License validation failed' });
+          }
+        } catch (e) {
+          resolve({ valid: false, message: 'Invalid response from license server' });
+        }
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({
+        valid: false,
+        message: 'License server timeout. Check your internet connection.'
+      });
+    });
+
+    req.on('error', (err) => {
+      if (err.code === 'ENOTFOUND') {
+        resolve({
+          valid: false,
+          message: 'Cannot reach license server. Check your internet connection.'
+        });
+      } else {
+        resolve({
+          valid: false,
+          message: `Network error: ${err.message}`
+        });
+      }
+    });
+
+    req.write(data);
+    req.end();
+  });
+}
+
+module.exports = { validateLicense };