@l4yercak3/cli 1.2.16 → 1.2.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@l4yercak3/cli",
-  "version": "1.2.16",
+  "version": "1.2.19",
   "description": "Icing on the L4yercak3 - The sweet finishing touch for your Layer Cake integration",
   "main": "src/index.js",
   "bin": {

package/src/commands/login.js

@@ -232,6 +232,18 @@ async function handleLogin() {
   }
 }
 
+/**
+ * Get friendly framework name for display
+ */
+function getFrameworkDisplayName(frameworkType) {
+  const names = {
+    'nextjs': 'Next.js',
+    'expo': 'Expo',
+    'react-native': 'React Native',
+  };
+  return names[frameworkType] || frameworkType;
+}
+
 /**
  * Prompt user to run the setup wizard after login
  */
@@ -243,7 +255,7 @@ async function promptSetupWizard() {
   const isInProject = detection.framework.type !== null;
 
   if (isInProject) {
-    const frameworkName = detection.framework.type === 'nextjs' ? 'Next.js' : detection.framework.type;
+    const frameworkName = getFrameworkDisplayName(detection.framework.type);
     console.log(chalk.cyan(`  🔍 Detected ${frameworkName} project in current directory\n`));
 
     // Check if project is already configured
@@ -280,6 +292,10 @@ async function promptSetupWizard() {
 
       if (!runWizard) {
         console.log('');
+        console.log(chalk.yellow(`  ℹ️  To generate ${frameworkName}-specific code later, run:\n`));
+        console.log(chalk.cyan('     l4yercak3 spread\n'));
+        console.log(chalk.gray('  This will create components, hooks, and screens'));
+        console.log(chalk.gray(`  optimized for ${frameworkName}.\n`));
         const action = await showPostLoginMenu({ isInProject: true, hasExistingConfig: false });
         await executeMenuAction(action);
         return;
@@ -294,14 +310,17 @@ async function promptSetupWizard() {
   } else {
     // Not in a project directory
     console.log(chalk.cyan('  📋 What\'s Next?\n'));
-    console.log(chalk.gray('  To integrate L4YERCAK3 with your Next.js project:'));
+    console.log(chalk.gray('  To integrate L4YERCAK3 with your project:\n'));
     console.log(chalk.gray('  1. Navigate to your project directory'));
     console.log(chalk.gray('  2. Run: l4yercak3 spread\n'));
-    console.log(chalk.gray('  This will set up:'));
-    console.log(chalk.gray('  • API client for backend communication'));
-    console.log(chalk.gray('  • Environment variables'));
-    console.log(chalk.gray('  • OAuth authentication (optional)'));
-    console.log(chalk.gray('  • CRM, Projects, and Invoices integration\n'));
+    console.log(chalk.gray('  Supported frameworks:'));
+    console.log(chalk.gray('  • Next.js (App Router & Pages Router)'));
+    console.log(chalk.gray('  • Expo / React Native\n'));
+    console.log(chalk.gray('  The spread command will:'));
+    console.log(chalk.gray('  • Detect your framework automatically'));
+    console.log(chalk.gray('  • Generate platform-specific components'));
+    console.log(chalk.gray('  • Set up API client & environment variables'));
+    console.log(chalk.gray('  • Configure OAuth authentication (optional)\n'));
   }
 }
 

package/src/commands/spread.js

@@ -5,6 +5,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { execSync } = require('child_process');
 const configManager = require('../config/config-manager');
 const backendClient = require('../api/backend-client');
 const projectDetector = require('../detectors');
@@ -54,6 +55,124 @@ async function generateNewApiKey(organizationId) {
   return apiKey;
 }
 
+/**
+ * Check if the project is a git repository
+ */
+function isGitRepo(projectPath) {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', {
+      cwd: projectPath,
+      stdio: 'pipe',
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get git status (uncommitted changes)
+ */
+function getGitStatus(projectPath) {
+  try {
+    const status = execSync('git status --porcelain', {
+      cwd: projectPath,
+      encoding: 'utf8',
+    });
+    return status.trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Check for uncommitted changes and prompt user to commit first
+ * Returns true if we should proceed, false if user wants to abort
+ */
+async function checkGitStatusBeforeGeneration(projectPath) {
+  // Skip if not a git repo
+  if (!isGitRepo(projectPath)) {
+    return true;
+  }
+
+  const status = getGitStatus(projectPath);
+
+  // No uncommitted changes - proceed
+  if (!status) {
+    return true;
+  }
+
+  // Count changes
+  const changes = status.split('\n').filter(line => line.trim());
+  const modifiedCount = changes.filter(line => line.startsWith(' M') || line.startsWith('M ')).length;
+  const untrackedCount = changes.filter(line => line.startsWith('??')).length;
+  const stagedCount = changes.filter(line => /^[MADRC]/.test(line)).length;
+
+  console.log(chalk.yellow('  ⚠️  Uncommitted changes detected\n'));
+
+  if (modifiedCount > 0) {
+    console.log(chalk.gray(`     ${modifiedCount} modified file(s)`));
+  }
+  if (untrackedCount > 0) {
+    console.log(chalk.gray(`     ${untrackedCount} untracked file(s)`));
+  }
+  if (stagedCount > 0) {
+    console.log(chalk.gray(`     ${stagedCount} staged file(s)`));
+  }
+
+  console.log('');
+  console.log(chalk.gray('  We recommend committing your changes before generating'));
+  console.log(chalk.gray('  new files, so you can easily revert if needed.\n'));
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'How would you like to proceed?',
+      choices: [
+        {
+          name: 'Continue anyway - I\'ll handle it later',
+          value: 'continue',
+        },
+        {
+          name: 'Commit changes now - Create a checkpoint commit',
+          value: 'commit',
+        },
+        {
+          name: 'Abort - I\'ll commit manually first',
+          value: 'abort',
+        },
+      ],
+    },
+  ]);
+
+  if (action === 'abort') {
+    console.log(chalk.gray('\n  No worries! Run "l4yercak3 spread" again after committing.\n'));
+    return false;
+  }
+
+  if (action === 'commit') {
+    try {
+      // Stage all changes
+      execSync('git add -A', { cwd: projectPath, stdio: 'pipe' });
+
+      // Create commit
+      const commitMessage = 'chore: checkpoint before L4YERCAK3 integration';
+      execSync(`git commit -m "${commitMessage}"`, { cwd: projectPath, stdio: 'pipe' });
+
+      console.log(chalk.green('\n  ✅ Changes committed successfully'));
+      console.log(chalk.gray(`     Message: "${commitMessage}"`));
+      console.log(chalk.gray('     You can revert with: git reset --soft HEAD~1\n'));
+    } catch (error) {
+      console.log(chalk.yellow('\n  ⚠️  Could not create commit automatically'));
+      console.log(chalk.gray(`     ${error.message}`));
+      console.log(chalk.gray('     Proceeding with file generation anyway...\n'));
+    }
+  }
+
+  return true;
+}
+
 async function handleSpread() {
   // Check if logged in
   if (!configManager.isLoggedIn()) {
@@ -71,11 +190,17 @@ async function handleSpread() {
     
     // Display framework detection results
     if (detection.framework.type) {
-      const frameworkName = detection.framework.type === 'nextjs' ? 'Next.js' : detection.framework.type;
+      const frameworkNames = {
+        'nextjs': 'Next.js',
+        'expo': 'Expo',
+        'react-native': 'React Native',
+      };
+      const frameworkName = frameworkNames[detection.framework.type] || detection.framework.type;
       console.log(chalk.green(`  ✅ Detected ${frameworkName} project`));
-      
+
+      const meta = detection.framework.metadata || {};
+
       if (detection.framework.type === 'nextjs') {
-        const meta = detection.framework.metadata;
         if (meta.version) {
           console.log(chalk.gray(`     Version: ${meta.version}`));
         }
@@ -85,6 +210,21 @@ async function handleSpread() {
         if (meta.hasTypeScript) {
           console.log(chalk.gray('     TypeScript: Yes'));
         }
+      } else if (detection.framework.type === 'expo' || detection.framework.type === 'react-native') {
+        if (meta.expoVersion) {
+          console.log(chalk.gray(`     Expo SDK: ${meta.expoVersion}`));
+        }
+        if (meta.reactNativeVersion) {
+          console.log(chalk.gray(`     React Native: ${meta.reactNativeVersion}`));
+        }
+        if (meta.routerType) {
+          const routerName = meta.routerType === 'expo-router' ? 'Expo Router' :
+                            meta.routerType === 'react-navigation' ? 'React Navigation' : 'Native';
+          console.log(chalk.gray(`     Navigation: ${routerName}`));
+        }
+        if (meta.hasTypeScript) {
+          console.log(chalk.gray('     TypeScript: Yes'));
+        }
       }
       
       // Show supported features
@@ -405,17 +545,83 @@ async function handleSpread() {
         choices: [
           { name: 'CRM (contacts, organizations)', value: 'crm', checked: true },
           { name: 'Events (event management, registrations)', value: 'events', checked: false },
-          { name: 'Products (product catalog)', value: 'products', checked: false },
-          { name: 'Checkout (payment processing)', value: 'checkout', checked: false },
-          { name: 'Tickets (ticket generation)', value: 'tickets', checked: false },
-          { name: 'Invoicing (invoice creation)', value: 'invoicing', checked: false },
-          { name: 'Forms (dynamic forms)', value: 'forms', checked: false },
-          { name: 'Projects (project management)', value: 'projects', checked: false },
+          { name: 'Forms (form builder, submissions)', value: 'forms', checked: false },
+          { name: 'Products (product catalog, inventory)', value: 'products', checked: false },
+          { name: 'Checkout (cart, payments)', value: 'checkout', checked: false },
+          { name: 'Invoicing (B2B/B2C invoices)', value: 'invoicing', checked: false },
+          { name: 'Benefits (claims, commissions)', value: 'benefits', checked: false },
+          { name: 'Certificates (CME, attendance)', value: 'certificates', checked: false },
+          { name: 'Projects (task management)', value: 'projects', checked: false },
           { name: 'OAuth Authentication', value: 'oauth', checked: false },
         ],
       },
     ]);
 
+    // Step 4.5: Integration path selection
+    console.log(chalk.cyan('\n  🛤️  Integration Path\n'));
+    const { integrationPath } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'integrationPath',
+        message: 'Choose your integration approach:',
+        choices: [
+          {
+            name: 'Quick Start (Recommended) - Full-stack with UI components & database',
+            value: 'quickstart',
+          },
+          {
+            name: 'API Only - Just the typed API client, you build the UI',
+            value: 'api-only',
+          },
+          {
+            name: 'MCP-Assisted - AI-powered custom generation with Claude Code',
+            value: 'mcp-assisted',
+          },
+        ],
+      },
+    ]);
+    console.log(chalk.green(`  ✅ Path: ${integrationPath === 'quickstart' ? 'Quick Start' : integrationPath === 'api-only' ? 'API Only' : 'MCP-Assisted'}\n`));
+
+    // Step 4.6: Database selection (for Quick Start path when no DB detected)
+    let selectedDatabase = null;
+    if (integrationPath === 'quickstart') {
+      const dbDetection = detection.database || { hasDatabase: false };
+
+      if (!dbDetection.hasDatabase) {
+        console.log(chalk.yellow('  ℹ️  No database detected in your project.\n'));
+
+        const { database } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'database',
+            message: 'Which database would you like to use?',
+            choices: [
+              {
+                name: 'Convex (Recommended) - Real-time, serverless, TypeScript-first',
+                value: 'convex',
+              },
+              {
+                name: 'Supabase - PostgreSQL with Auth, Storage, and Edge Functions',
+                value: 'supabase',
+              },
+              {
+                name: 'None - I\'ll set up my own database later',
+                value: 'none',
+              },
+            ],
+          },
+        ]);
+
+        selectedDatabase = database !== 'none' ? database : null;
+        if (selectedDatabase) {
+          console.log(chalk.green(`  ✅ Database: ${selectedDatabase}\n`));
+        }
+      } else {
+        console.log(chalk.green(`  ✅ Detected ${dbDetection.primary?.type || 'existing'} database\n`));
+        selectedDatabase = dbDetection.primary?.type || 'existing';
+      }
+    }
+
     // Step 5: OAuth provider selection (if OAuth enabled)
     let oauthProviders = [];
     if (features.includes('oauth')) {
@@ -468,7 +674,13 @@ async function handleSpread() {
       }
     }
 
-    // Step 8: Generate files
+    // Step 8: Check for uncommitted changes before generating files
+    const shouldProceed = await checkGitStatusBeforeGeneration(detection.projectPath);
+    if (!shouldProceed) {
+      return;
+    }
+
+    // Step 9: Generate files
     console.log(chalk.cyan('\n  📝 Generating files...\n'));
 
     // Extract framework metadata for generation
@@ -489,15 +701,38 @@ async function handleSpread() {
       isTypeScript,
       routerType,
       frameworkType: detection.framework.type || 'unknown',
+      integrationPath,
+      selectedDatabase,
     };
 
     const generatedFiles = await fileGenerator.generate(generationOptions);
 
     // Display results
     console.log(chalk.green('  ✅ Files generated:\n'));
+
+    // API client files (api-only and quickstart paths)
     if (generatedFiles.apiClient) {
       console.log(chalk.gray(`     • ${path.relative(process.cwd(), generatedFiles.apiClient)}`));
     }
+    if (generatedFiles.types) {
+      console.log(chalk.gray(`     • ${path.relative(process.cwd(), generatedFiles.types)}`));
+    }
+    if (generatedFiles.webhooks) {
+      console.log(chalk.gray(`     • ${path.relative(process.cwd(), generatedFiles.webhooks)}`));
+    }
+    if (generatedFiles.index) {
+      console.log(chalk.gray(`     • ${path.relative(process.cwd(), generatedFiles.index)}`));
+    }
+
+    // MCP files (mcp-assisted path)
+    if (generatedFiles.mcpConfig) {
+      console.log(chalk.gray(`     • ${path.relative(process.cwd(), generatedFiles.mcpConfig)}`));
+    }
+    if (generatedFiles.mcpGuide) {
+      console.log(chalk.gray(`     • ${path.relative(process.cwd(), generatedFiles.mcpGuide)}`));
+    }
+
+    // Common files
     if (generatedFiles.envFile) {
       console.log(chalk.gray(`     • ${path.relative(process.cwd(), generatedFiles.envFile)}`));
     }
@@ -641,6 +876,8 @@ async function handleSpread() {
       oauthProviders,
       productionDomain,
       frameworkType: detection.framework.type,
+      integrationPath,
+      selectedDatabase,
       createdAt: Date.now(),
       updatedAt: isUpdate ? Date.now() : undefined,
     };
@@ -678,6 +915,10 @@ async function handleSpread() {
 
     console.log(chalk.gray('  Your project is now connected to L4YERCAK3! 🍰\n'));
 
+    // Show menu for next actions
+    const action = await showMainMenu({ isLoggedIn: true, isInProject: true, hasExistingConfig: true });
+    await executeMenuAction(action);
+
   } catch (error) {
     console.error(chalk.red(`\n  ❌ Error: ${error.message}\n`));
     if (error.stack) {

package/src/detectors/database-detector.js

@@ -0,0 +1,245 @@
+/**
+ * Database Detector
+ * Detects existing database configurations in a project
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Check if a file exists
+ * @param {string} filePath - Path to check
+ * @returns {boolean}
+ */
+function fileExists(filePath) {
+  try {
+    return fs.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Read and parse package.json
+ * @param {string} projectPath - Project root path
+ * @returns {object|null}
+ */
+function readPackageJson(projectPath) {
+  try {
+    const packagePath = path.join(projectPath, 'package.json');
+    if (fileExists(packagePath)) {
+      const content = fs.readFileSync(packagePath, 'utf8');
+      return JSON.parse(content);
+    }
+  } catch {
+    // Ignore parse errors
+  }
+  return null;
+}
+
+/**
+ * Detect database configuration in a project
+ * @param {string} projectPath - Project root path
+ * @returns {object} Detection result
+ */
+function detectDatabase(projectPath = process.cwd()) {
+  const detections = [];
+
+  // Check for Convex
+  const convexDir = path.join(projectPath, 'convex');
+  if (fileExists(convexDir)) {
+    const hasSchema = fileExists(path.join(convexDir, 'schema.ts')) ||
+                      fileExists(path.join(convexDir, 'schema.js'));
+    detections.push({
+      type: 'convex',
+      confidence: 'high',
+      configPath: 'convex/',
+      hasSchema,
+      details: {
+        schemaFile: hasSchema ? 'convex/schema.ts' : null,
+      },
+    });
+  }
+
+  // Check for Supabase
+  const supabaseDir = path.join(projectPath, 'supabase');
+  if (fileExists(supabaseDir)) {
+    const hasMigrations = fileExists(path.join(supabaseDir, 'migrations'));
+    detections.push({
+      type: 'supabase',
+      confidence: 'high',
+      configPath: 'supabase/',
+      hasMigrations,
+      details: {
+        migrationsDir: hasMigrations ? 'supabase/migrations/' : null,
+      },
+    });
+  }
+
+  // Check for Prisma
+  const prismaDir = path.join(projectPath, 'prisma');
+  if (fileExists(prismaDir)) {
+    const hasSchema = fileExists(path.join(prismaDir, 'schema.prisma'));
+    detections.push({
+      type: 'prisma',
+      confidence: 'high',
+      configPath: 'prisma/',
+      hasSchema,
+      details: {
+        schemaFile: hasSchema ? 'prisma/schema.prisma' : null,
+      },
+    });
+  }
+
+  // Check for Drizzle config
+  const drizzleConfig = [
+    'drizzle.config.ts',
+    'drizzle.config.js',
+    'drizzle.config.mjs',
+  ].find(f => fileExists(path.join(projectPath, f)));
+  if (drizzleConfig) {
+    detections.push({
+      type: 'drizzle',
+      confidence: 'high',
+      configPath: drizzleConfig,
+      details: {
+        configFile: drizzleConfig,
+      },
+    });
+  }
+
+  // Check package.json for database dependencies
+  const packageJson = readPackageJson(projectPath);
+  if (packageJson) {
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+
+    // Convex from package.json
+    if (deps['convex'] && !detections.find(d => d.type === 'convex')) {
+      detections.push({
+        type: 'convex',
+        confidence: 'medium',
+        source: 'package.json',
+        details: {
+          version: deps['convex'],
+        },
+      });
+    }
+
+    // Supabase from package.json
+    if (deps['@supabase/supabase-js'] && !detections.find(d => d.type === 'supabase')) {
+      detections.push({
+        type: 'supabase',
+        confidence: 'medium',
+        source: 'package.json',
+        details: {
+          version: deps['@supabase/supabase-js'],
+        },
+      });
+    }
+
+    // Prisma from package.json
+    if ((deps['prisma'] || deps['@prisma/client']) && !detections.find(d => d.type === 'prisma')) {
+      detections.push({
+        type: 'prisma',
+        confidence: 'medium',
+        source: 'package.json',
+        details: {
+          version: deps['prisma'] || deps['@prisma/client'],
+        },
+      });
+    }
+
+    // Drizzle from package.json
+    if (deps['drizzle-orm'] && !detections.find(d => d.type === 'drizzle')) {
+      detections.push({
+        type: 'drizzle',
+        confidence: 'medium',
+        source: 'package.json',
+        details: {
+          version: deps['drizzle-orm'],
+        },
+      });
+    }
+
+    // MongoDB/Mongoose
+    if (deps['mongoose']) {
+      detections.push({
+        type: 'mongodb',
+        confidence: 'medium',
+        source: 'package.json',
+        details: {
+          client: 'mongoose',
+          version: deps['mongoose'],
+        },
+      });
+    }
+
+    if (deps['mongodb'] && !detections.find(d => d.type === 'mongodb')) {
+      detections.push({
+        type: 'mongodb',
+        confidence: 'medium',
+        source: 'package.json',
+        details: {
+          client: 'mongodb',
+          version: deps['mongodb'],
+        },
+      });
+    }
+
+    // Firebase/Firestore
+    if (deps['firebase'] || deps['firebase-admin']) {
+      detections.push({
+        type: 'firebase',
+        confidence: 'medium',
+        source: 'package.json',
+        details: {
+          client: deps['firebase'] ? 'firebase' : 'firebase-admin',
+          version: deps['firebase'] || deps['firebase-admin'],
+        },
+      });
+    }
+
+    // PostgreSQL (pg)
+    if (deps['pg'] && !detections.find(d => ['prisma', 'drizzle', 'supabase'].includes(d.type))) {
+      detections.push({
+        type: 'postgresql',
+        confidence: 'low',
+        source: 'package.json',
+        details: {
+          client: 'pg',
+          version: deps['pg'],
+        },
+      });
+    }
+
+    // MySQL
+    if (deps['mysql2'] || deps['mysql']) {
+      detections.push({
+        type: 'mysql',
+        confidence: 'low',
+        source: 'package.json',
+        details: {
+          client: deps['mysql2'] ? 'mysql2' : 'mysql',
+          version: deps['mysql2'] || deps['mysql'],
+        },
+      });
+    }
+  }
+
+  // Sort by confidence (high first)
+  const sortedDetections = detections.sort((a, b) => {
+    const confidenceOrder = { high: 2, medium: 1, low: 0 };
+    return (confidenceOrder[b.confidence] || 0) - (confidenceOrder[a.confidence] || 0);
+  });
+
+  return {
+    hasDatabase: sortedDetections.length > 0,
+    detections: sortedDetections,
+    primary: sortedDetections[0] || null,
+  };
+}
+
+module.exports = {
+  detect: detectDatabase,
+  detectDatabase,
+};

package/src/detectors/expo-detector.js

@@ -13,7 +13,7 @@ class ExpoDetector extends BaseDetector {
   }
 
   get priority() {
-    return 95; // High priority - specific framework
+    return 95; // Slightly lower than Next.js (100), but high enough for framework detection
   }
 
   /**
@@ -106,11 +106,11 @@ class ExpoDetector extends BaseDetector {
       }
 
       // Determine confidence based on what we found
-      let confidence = 0.7; // Base confidence for React Native
+      let confidence = 0.85; // Base confidence for React Native
       if (results.isExpo) {
-        confidence = 0.9; // Higher for Expo
+        confidence = 0.9; // Higher confidence for Expo projects
         if (results.config) {
-          confidence = 0.95; // Even higher with config file
+          confidence = 0.95; // Even higher with config file (app.json)
         }
       }