@l4yercak3/cli 1.2.15 → 1.2.18

package/package.json

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

package/src/commands/spread.js

@@ -405,17 +405,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')) {
@@ -489,15 +555,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 +730,8 @@ async function handleSpread() {
       oauthProviders,
       productionDomain,
       frameworkType: detection.framework.type,
+      integrationPath,
+      selectedDatabase,
       createdAt: Date.now(),
       updatedAt: isUpdate ? Date.now() : undefined,
     };
@@ -678,6 +769,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/index.js

@@ -10,6 +10,7 @@ const registry = require('./registry');
 const githubDetector = require('./github-detector');
 const apiClientDetector = require('./api-client-detector');
 const oauthDetector = require('./oauth-detector');
+const databaseDetector = require('./database-detector');
 
 class ProjectDetector {
   /**
@@ -26,9 +27,10 @@ class ProjectDetector {
     const githubInfo = githubDetector.detect(projectPath);
     const apiClientInfo = apiClientDetector.detect(projectPath);
     const oauthInfo = oauthDetector.detect(projectPath);
+    const databaseInfo = databaseDetector.detect(projectPath);
 
     // Get detector instance if we have a match
-    const detector = frameworkDetection.detected 
+    const detector = frameworkDetection.detected
       ? registry.getDetector(frameworkDetection.detected)
       : null;
 
@@ -41,22 +43,33 @@ class ProjectDetector {
         supportedFeatures: detector?.getSupportedFeatures() || {},
         availableGenerators: detector?.getAvailableGenerators() || [],
       },
-      
+
       // Project metadata (framework-agnostic)
       github: githubInfo,
       apiClient: apiClientInfo,
       oauth: oauthInfo,
-      
+      database: databaseInfo,
+
       // Raw detection results (for debugging)
       _raw: {
         frameworkResults: frameworkDetection.allResults,
       },
-      
+
       // Project path
       projectPath,
     };
   }
 
+  /**
+   * Detect database configuration in a project
+   *
+   * @param {string} projectPath - Path to project directory
+   * @returns {object} Database detection results
+   */
+  detectDatabase(projectPath = process.cwd()) {
+    return databaseDetector.detect(projectPath);
+  }
+
   /**
    * Get detector for a specific project type
    *