@l4yercak3/cli 1.2.21 → 1.3.1

package/src/commands/spread.js

@@ -5,198 +5,27 @@
 
 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');
 const fileGenerator = require('../generators');
+const manifestGenerator = require('../generators/manifest-generator');
+const pageDetector = require('../detectors/page-detector');
+const { suggestMappings } = require('../detectors/mapping-suggestor');
 const { generateProjectPathHash } = require('../utils/file-utils');
+const {
+  createOrganization,
+  generateNewApiKey,
+  checkGitStatusBeforeGeneration,
+  requireAuth,
+} = require('../utils/init-helpers');
 const inquirer = require('inquirer');
 const chalk = require('chalk');
 const pkg = require('../../package.json');
 const { showMainMenu, executeMenuAction } = require('../utils/prompt-utils');
 
-/**
- * Helper function to create an organization
- */
-async function createOrganization(orgName) {
-  console.log(chalk.gray(`  Creating organization "${orgName}"...`));
-  const newOrg = await backendClient.createOrganization(orgName);
-  // Handle different response formats
-  const organizationId = newOrg.organizationId || newOrg.id || newOrg.data?.organizationId || newOrg.data?.id;
-  const organizationName = newOrg.name || orgName;
-
-  if (!organizationId) {
-    throw new Error('Organization ID not found in response. Please check backend API endpoint.');
-  }
-
-  console.log(chalk.green(`  ✅ Organization created: ${organizationName}\n`));
-  return { organizationId, organizationName };
-}
-
-/**
- * Helper function to generate a new API key
- */
-async function generateNewApiKey(organizationId) {
-  console.log(chalk.gray('  Generating API key...'));
-  const apiKeyResponse = await backendClient.generateApiKey(
-    organizationId,
-    'CLI Generated Key',
-    ['*']
-  );
-  // Handle different response formats
-  const apiKey = apiKeyResponse.key || apiKeyResponse.apiKey || apiKeyResponse.data?.key || apiKeyResponse.data?.apiKey;
-
-  if (!apiKey) {
-    throw new Error('API key not found in response. Please check backend API endpoint.');
-  }
-
-  console.log(chalk.green(`  ✅ API key generated\n`));
-  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) {
-  const debug = process.env.L4YERCAK3_DEBUG;
-
-  if (debug) {
-    console.log('\n[DEBUG] Git status check:');
-    console.log(`  projectPath: "${projectPath}"`);
-  }
-
-  // Skip if not a git repo
-  if (!isGitRepo(projectPath)) {
-    if (debug) {
-      console.log('  → Not a git repo, skipping check');
-    }
-    return true;
-  }
-
-  const status = getGitStatus(projectPath);
-
-  if (debug) {
-    console.log(`  → Git status: "${status.substring(0, 100)}${status.length > 100 ? '...' : ''}"`);
-  }
-
-  // No uncommitted changes - proceed
-  if (!status) {
-    if (debug) {
-      console.log('  → No uncommitted changes, proceeding');
-    }
-    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()) {
-    console.log(chalk.yellow('  ⚠️  You must be logged in first'));
-    console.log(chalk.gray('\n  Run "l4yercak3 login" to authenticate\n'));
-    process.exit(1);
-  }
+  requireAuth(configManager);
 
   console.log(chalk.cyan('  🍰 Setting up your Layer Cake integration...\n'));
 
@@ -293,6 +122,45 @@ async function handleSpread() {
       }
     }
 
+    // Display model detection
+    if (detection.models && detection.models.hasModels) {
+      console.log(chalk.green(`  ✅ Detected ${detection.models.models.length} model(s)`));
+      for (const model of detection.models.models.slice(0, 5)) {
+        console.log(chalk.gray(`     • ${model.name} (${model.source}) [${model.fields.length} fields]`));
+      }
+      if (detection.models.models.length > 5) {
+        console.log(chalk.gray(`     ... and ${detection.models.models.length - 5} more`));
+      }
+    }
+
+    // Scan routes with HTTP methods
+    const detectedRoutes = pageDetector.detect(
+      detection.projectPath,
+      detection.framework.type,
+      detection.framework.metadata || {}
+    );
+    const apiRoutes = detectedRoutes.filter(r => r.pageType === 'api_route');
+    if (apiRoutes.length > 0) {
+      console.log(chalk.green(`  ✅ Detected ${apiRoutes.length} API route(s)`));
+      for (const route of apiRoutes.slice(0, 5)) {
+        const methods = route.methods ? route.methods.join(', ') : 'GET, POST';
+        console.log(chalk.gray(`     • ${route.path} [${methods}]`));
+      }
+      if (apiRoutes.length > 5) {
+        console.log(chalk.gray(`     ... and ${apiRoutes.length - 5} more`));
+      }
+    }
+
+    // Compute suggested mappings
+    const models = detection.models ? detection.models.models : [];
+    const mappings = suggestMappings(models);
+    if (mappings.length > 0) {
+      console.log(chalk.green(`  ✅ ${mappings.length} suggested mapping(s)`));
+      for (const mapping of mappings) {
+        console.log(chalk.gray(`     • ${mapping.localModel} → ${mapping.platformType} (${mapping.confidence}% confidence)`));
+      }
+    }
+
     console.log('');
 
     // Step 1.5: Project name
@@ -553,22 +421,43 @@ async function handleSpread() {
     }
 
     // Step 4: Feature selection
+    // Auto-check features based on detected model mappings
+    const platformTypeToFeature = {
+      contact: 'crm',
+      booking: 'events',
+      event: 'events',
+      product: 'products',
+      invoice: 'invoicing',
+      project: 'projects',
+      form: 'forms',
+      certificate: 'certificates',
+      benefit: 'benefits',
+    };
+    const autoCheckedFeatures = new Set(['crm']); // CRM always default
+    for (const mapping of mappings) {
+      const feature = platformTypeToFeature[mapping.platformType];
+      if (feature) autoCheckedFeatures.add(feature);
+    }
+
     console.log(chalk.cyan('  ⚙️  Feature Selection\n'));
+    if (mappings.length > 0) {
+      console.log(chalk.gray('  Features pre-selected based on detected models:\n'));
+    }
     const { features } = await inquirer.prompt([
       {
         type: 'checkbox',
         name: 'features',
         message: 'Select features to enable:',
         choices: [
-          { name: 'CRM (contacts, organizations)', value: 'crm', checked: true },
-          { name: 'Events (event management, registrations)', value: 'events', 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: 'CRM (contacts, organizations)', value: 'crm', checked: autoCheckedFeatures.has('crm') },
+          { name: 'Events (event management, registrations)', value: 'events', checked: autoCheckedFeatures.has('events') },
+          { name: 'Forms (form builder, submissions)', value: 'forms', checked: autoCheckedFeatures.has('forms') },
+          { name: 'Products (product catalog, inventory)', value: 'products', checked: autoCheckedFeatures.has('products') },
+          { name: 'Checkout (cart, payments)', value: 'checkout', checked: autoCheckedFeatures.has('checkout') },
+          { name: 'Invoicing (B2B/B2C invoices)', value: 'invoicing', checked: autoCheckedFeatures.has('invoicing') },
+          { name: 'Benefits (claims, commissions)', value: 'benefits', checked: autoCheckedFeatures.has('benefits') },
+          { name: 'Certificates (CME, attendance)', value: 'certificates', checked: autoCheckedFeatures.has('certificates') },
+          { name: 'Projects (task management)', value: 'projects', checked: autoCheckedFeatures.has('projects') },
           { name: 'OAuth Authentication', value: 'oauth', checked: false },
         ],
       },
@@ -772,6 +661,16 @@ async function handleSpread() {
       console.log(chalk.gray(`     • ${path.relative(process.cwd(), generatedFiles.gitignore)} (updated)`));
     }
 
+    // Generate .l4yercak3.json manifest
+    const manifestPath = manifestGenerator.generate({
+      projectPath: detection.projectPath,
+      detection,
+      models,
+      routes: detectedRoutes,
+      mappings,
+    });
+    console.log(chalk.gray(`     • ${path.relative(process.cwd(), manifestPath)}`));
+
     // Step 9: Register application with backend
     console.log(chalk.cyan('\n  🔗 Registering with L4YERCAK3...\n'));
 

package/src/commands/sync.js

@@ -0,0 +1,169 @@
+/**
+ * Sync Command
+ * Re-detects project structure and syncs the manifest with the L4YERCAK3 platform
+ *
+ * Flow:
+ * 1. Re-run all detectors (models, routes, pages)
+ * 2. Re-compute suggested mappings
+ * 3. Diff old manifest vs new detection results
+ * 4. Write updated .l4yercak3.json
+ * 5. Push manifest to platform if connected
+ */
+
+const configManager = require('../config/config-manager');
+const backendClient = require('../api/backend-client');
+const projectDetector = require('../detectors');
+const pageDetector = require('../detectors/page-detector');
+const { suggestMappings } = require('../detectors/mapping-suggestor');
+const manifestGenerator = require('../generators/manifest-generator');
+const { requireAuth } = require('../utils/init-helpers');
+const chalk = require('chalk');
+
+async function handleSync() {
+  requireAuth(configManager);
+
+  console.log(chalk.cyan('  🔄 Syncing project structure...\n'));
+
+  try {
+    const projectPath = process.cwd();
+
+    // Step 1: Load existing manifest
+    const existingManifest = manifestGenerator.loadManifest(projectPath);
+    if (!existingManifest) {
+      console.log(chalk.yellow('  ⚠️  No .l4yercak3.json manifest found.'));
+      console.log(chalk.gray('     Run "l4yercak3 init" first to scan your project.\n'));
+      process.exit(1);
+    }
+
+    console.log(chalk.gray('  Loading existing manifest...'));
+    console.log(chalk.gray(`     Framework: ${existingManifest.framework}`));
+    console.log(chalk.gray(`     Models: ${existingManifest.detectedModels?.length || 0}`));
+    console.log(chalk.gray(`     Routes: ${existingManifest.detectedRoutes?.length || 0}`));
+    console.log(chalk.gray(`     Last synced: ${existingManifest.lastSyncedAt || 'never'}\n`));
+
+    // Step 2: Re-run detection
+    console.log(chalk.gray('  🔍 Re-scanning project...\n'));
+    const detection = projectDetector.detect(projectPath);
+
+    // Step 3: Re-scan routes with methods
+    const detectedRoutes = pageDetector.detect(
+      projectPath,
+      detection.framework.type,
+      detection.framework.metadata || {}
+    );
+
+    // Step 4: Re-compute mappings
+    const models = detection.models ? detection.models.models : [];
+    const mappings = suggestMappings(models);
+
+    // Step 5: Build new manifest data for diff
+    const newManifestData = {
+      version: existingManifest.version || '1.0.0',
+      framework: detection.framework.type || existingManifest.framework,
+      routerType: detection.framework.metadata?.routerType || existingManifest.routerType,
+      typescript: detection.framework.metadata?.hasTypeScript || existingManifest.typescript,
+      database: detection.database?.primary?.type || existingManifest.database,
+      detectedModels: models.map(m => ({
+        name: m.name,
+        source: m.source,
+        fields: m.fields || [],
+      })),
+      detectedRoutes: detectedRoutes
+        .filter(r => r.pageType === 'api_route')
+        .map(r => ({
+          path: r.path,
+          methods: r.methods || ['GET', 'POST'],
+        })),
+      suggestedMappings: mappings.map(m => ({
+        localModel: m.localModel,
+        platformType: m.platformType,
+        confidence: m.confidence,
+      })),
+    };
+
+    // Step 6: Compute diff
+    const diff = manifestGenerator.diff(existingManifest, newManifestData);
+
+    if (!diff.hasChanges) {
+      console.log(chalk.green('  ✅ No changes detected. Your manifest is up to date.\n'));
+    } else {
+      console.log(chalk.cyan('  📊 Changes detected:\n'));
+
+      if (diff.modelsAdded.length > 0) {
+        console.log(chalk.green(`     + ${diff.modelsAdded.length} new model(s)`));
+        for (const m of diff.modelsAdded) {
+          console.log(chalk.gray(`       • ${m.name} (${m.source})`));
+        }
+      }
+
+      if (diff.modelsRemoved.length > 0) {
+        console.log(chalk.red(`     - ${diff.modelsRemoved.length} removed model(s)`));
+        for (const m of diff.modelsRemoved) {
+          console.log(chalk.gray(`       • ${m.name} (${m.source})`));
+        }
+      }
+
+      if (diff.routesAdded.length > 0) {
+        console.log(chalk.green(`     + ${diff.routesAdded.length} new route(s)`));
+        for (const r of diff.routesAdded) {
+          console.log(chalk.gray(`       • ${r.path} [${(r.methods || []).join(', ')}]`));
+        }
+      }
+
+      if (diff.routesRemoved.length > 0) {
+        console.log(chalk.red(`     - ${diff.routesRemoved.length} removed route(s)`));
+        for (const r of diff.routesRemoved) {
+          console.log(chalk.gray(`       • ${r.path}`));
+        }
+      }
+
+      console.log('');
+    }
+
+    // Step 7: Write updated manifest
+    manifestGenerator.generate({
+      projectPath,
+      detection,
+      models,
+      routes: detectedRoutes,
+      mappings,
+    });
+    console.log(chalk.green(`  ✅ Manifest updated: .l4yercak3.json`));
+
+    // Step 8: Summary
+    console.log(chalk.gray(`     Models: ${newManifestData.detectedModels.length}`));
+    console.log(chalk.gray(`     Routes: ${newManifestData.detectedRoutes.length}`));
+    console.log(chalk.gray(`     Mappings: ${newManifestData.suggestedMappings.length}\n`));
+
+    // Step 9: Push to platform if connected
+    const projectConfig = configManager.getProjectConfig(projectPath);
+    if (projectConfig && projectConfig.applicationId) {
+      console.log(chalk.gray('  Syncing to platform...'));
+      try {
+        const updatedManifest = manifestGenerator.loadManifest(projectPath);
+        await backendClient.syncManifest(projectConfig.applicationId, updatedManifest);
+        console.log(chalk.green('  ✅ Manifest synced to L4YERCAK3 platform\n'));
+      } catch (syncError) {
+        console.log(chalk.yellow(`  ⚠️  Could not sync to platform: ${syncError.message}`));
+        console.log(chalk.gray('     The manifest was updated locally. Platform sync may not be available yet.\n'));
+      }
+    } else {
+      console.log(chalk.gray('  ℹ️  Not connected to platform. Run "l4yercak3 connect" to enable remote sync.\n'));
+    }
+
+    console.log(chalk.cyan('  🎉 Sync complete!\n'));
+
+  } catch (error) {
+    console.error(chalk.red(`\n  ❌ Error: ${error.message}\n`));
+    if (process.env.L4YERCAK3_DEBUG && error.stack) {
+      console.error(chalk.gray(error.stack));
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  command: 'sync',
+  description: 'Re-detect project structure and sync with L4YERCAK3',
+  handler: handleSync,
+};

package/src/detectors/index.js

@@ -11,6 +11,7 @@ const githubDetector = require('./github-detector');
 const apiClientDetector = require('./api-client-detector');
 const oauthDetector = require('./oauth-detector');
 const databaseDetector = require('./database-detector');
+const modelDetector = require('./model-detector');
 
 class ProjectDetector {
   /**
@@ -28,6 +29,7 @@ class ProjectDetector {
     const apiClientInfo = apiClientDetector.detect(projectPath);
     const oauthInfo = oauthDetector.detect(projectPath);
     const databaseInfo = databaseDetector.detect(projectPath);
+    const modelInfo = modelDetector.detect(projectPath);
 
     // Get detector instance if we have a match
     const detector = frameworkDetection.detected
@@ -49,6 +51,7 @@ class ProjectDetector {
       apiClient: apiClientInfo,
       oauth: oauthInfo,
       database: databaseInfo,
+      models: modelInfo,
 
       // Raw detection results (for debugging)
       _raw: {
@@ -60,6 +63,16 @@ class ProjectDetector {
     };
   }
 
+  /**
+   * Detect models/types in a project
+   *
+   * @param {string} projectPath - Path to project directory
+   * @returns {object} Model detection results
+   */
+  detectModels(projectPath = process.cwd()) {
+    return modelDetector.detect(projectPath);
+  }
+
   /**
    * Detect database configuration in a project
    *

package/src/detectors/mapping-suggestor.js

@@ -0,0 +1,119 @@
+/**
+ * Mapping Suggestor
+ * Suggests mappings between local data models and L4YERCAK3 platform types
+ * Pure logic module — no I/O
+ */
+
+/**
+ * Platform types supported by L4YERCAK3
+ */
+const PLATFORM_TYPES = [
+  'contact',
+  'booking',
+  'event',
+  'product',
+  'invoice',
+  'project',
+  'form',
+  'certificate',
+  'benefit',
+];
+
+/**
+ * Mapping rules: keyword patterns → platform type + base confidence
+ * Patterns are matched against lowercase model names
+ */
+const MAPPING_RULES = [
+  {
+    patterns: ['user', 'customer', 'client', 'member', 'contact', 'person', 'lead', 'subscriber', 'account', 'profile'],
+    type: 'contact',
+    confidence: 90,
+  },
+  {
+    patterns: ['appointment', 'booking', 'reservation', 'schedule', 'slot'],
+    type: 'booking',
+    confidence: 85,
+  },
+  {
+    patterns: ['event', 'meeting', 'conference', 'webinar', 'session', 'workshop'],
+    type: 'event',
+    confidence: 85,
+  },
+  {
+    patterns: ['product', 'item', 'sku', 'merchandise', 'listing', 'catalog'],
+    type: 'product',
+    confidence: 85,
+  },
+  {
+    patterns: ['invoice', 'bill', 'receipt', 'charge', 'payment', 'order', 'transaction'],
+    type: 'invoice',
+    confidence: 80,
+  },
+  {
+    patterns: ['project', 'task', 'ticket', 'issue', 'sprint', 'milestone'],
+    type: 'project',
+    confidence: 80,
+  },
+  {
+    patterns: ['form', 'survey', 'questionnaire', 'submission', 'response'],
+    type: 'form',
+    confidence: 80,
+  },
+  {
+    patterns: ['certificate', 'credential', 'badge', 'diploma', 'cme', 'license'],
+    type: 'certificate',
+    confidence: 75,
+  },
+  {
+    patterns: ['benefit', 'claim', 'commission', 'payout', 'reward', 'bonus'],
+    type: 'benefit',
+    confidence: 75,
+  },
+];
+
+/**
+ * Suggest platform type mappings for detected models
+ * @param {Array<{name: string, source: string, fields: string[]}>} models
+ * @returns {Array<{localModel: string, platformType: string, confidence: number}>}
+ */
+function suggestMappings(models) {
+  if (!models || models.length === 0) return [];
+
+  const mappings = [];
+
+  for (const model of models) {
+    const lowerName = model.name.toLowerCase();
+    let bestMatch = null;
+
+    for (const rule of MAPPING_RULES) {
+      for (const pattern of rule.patterns) {
+        if (lowerName.includes(pattern)) {
+          // Exact match gets higher confidence
+          const isExact = lowerName === pattern;
+          const confidence = isExact ? Math.min(rule.confidence + 5, 99) : rule.confidence;
+
+          if (!bestMatch || confidence > bestMatch.confidence) {
+            bestMatch = {
+              localModel: model.name,
+              platformType: rule.type,
+              confidence,
+            };
+          }
+          break; // Only need first pattern match per rule
+        }
+      }
+    }
+
+    if (bestMatch) {
+      mappings.push(bestMatch);
+    }
+  }
+
+  return mappings;
+}
+
+module.exports = {
+  suggestMappings,
+  PLATFORM_TYPES,
+  MAPPING_RULES,
+};