@l4yercak3/cli 1.2.20 → 1.3.0

package/src/commands/scaffold.js

@@ -0,0 +1,409 @@
+/**
+ * Scaffold Command
+ * Generates integration files based on the project manifest (.l4yercak3.json)
+ * Diff-aware: only creates files that don't already exist
+ */
+
+const fs = require('fs');
+const path = require('path');
+const configManager = require('../config/config-manager');
+const manifestGenerator = require('../generators/manifest-generator');
+const { ensureDir, checkFileOverwrite, GENERATED_HEADER } = require('../utils/file-utils');
+const { requireAuth } = require('../utils/init-helpers');
+const chalk = require('chalk');
+
+async function handleScaffold() {
+  requireAuth(configManager);
+
+  console.log(chalk.cyan('  📦 Scaffolding integration files...\n'));
+
+  try {
+    const projectPath = process.cwd();
+
+    // Step 1: Load manifest
+    const manifest = manifestGenerator.loadManifest(projectPath);
+    if (!manifest) {
+      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);
+    }
+
+    const framework = manifest.framework || 'unknown';
+    const routerType = manifest.routerType || 'pages';
+    const isTypeScript = manifest.typescript || false;
+    const ext = isTypeScript ? 'ts' : 'js';
+
+    console.log(chalk.green(`  ✅ Loaded manifest: ${framework} (${routerType} router, ${isTypeScript ? 'TypeScript' : 'JavaScript'})`));
+    console.log(chalk.gray(`     ${manifest.detectedModels?.length || 0} models, ${manifest.detectedRoutes?.length || 0} routes\n`));
+
+    // Step 2: Determine which files to generate
+    const filesToGenerate = [];
+
+    // a) lib/l4yercak3 client wrapper
+    const clientDir = path.join(projectPath, 'lib');
+    const clientFile = path.join(clientDir, `l4yercak3.${ext}`);
+    filesToGenerate.push({
+      path: clientFile,
+      name: `lib/l4yercak3.${ext}`,
+      content: generateClientWrapper(manifest, isTypeScript),
+    });
+
+    // b) Webhook handler (framework-specific path)
+    let webhookFile;
+    if (framework === 'nextjs' && routerType === 'app') {
+      webhookFile = path.join(projectPath, 'app', 'api', 'webhooks', 'l4yercak3', `route.${ext}`);
+    } else if (framework === 'nextjs') {
+      webhookFile = path.join(projectPath, 'pages', 'api', 'webhooks', `l4yercak3.${ext}`);
+    }
+
+    if (webhookFile) {
+      const relPath = path.relative(projectPath, webhookFile);
+      filesToGenerate.push({
+        path: webhookFile,
+        name: relPath,
+        content: generateWebhookHandler(manifest, isTypeScript, routerType),
+      });
+    }
+
+    // c) Types file (if TypeScript and has models/mappings)
+    if (isTypeScript && manifest.detectedModels?.length > 0) {
+      const typesDir = path.join(projectPath, 'types');
+      const typesFile = path.join(typesDir, 'l4yercak3.ts');
+      filesToGenerate.push({
+        path: typesFile,
+        name: 'types/l4yercak3.ts',
+        content: generateTypes(manifest),
+      });
+    }
+
+    // Step 3: Diff-aware generation
+    console.log(chalk.cyan('  🔍 Checking existing files...\n'));
+    const created = [];
+    const skipped = [];
+
+    for (const file of filesToGenerate) {
+      const action = await checkFileOverwrite(file.path, { defaultAction: 'skip' });
+
+      if (action === 'skip') {
+        skipped.push(file.name);
+        continue;
+      }
+
+      // Ensure directory exists
+      ensureDir(path.dirname(file.path));
+
+      // Write file
+      fs.writeFileSync(file.path, file.content, 'utf8');
+      created.push(file.name);
+    }
+
+    // Step 4: Display results
+    if (created.length > 0) {
+      console.log(chalk.green('  ✅ Files created:\n'));
+      for (const name of created) {
+        console.log(chalk.gray(`     • ${name}`));
+      }
+    }
+
+    if (skipped.length > 0) {
+      console.log(chalk.gray(`\n  ⏭️  Skipped (already exist):\n`));
+      for (const name of skipped) {
+        console.log(chalk.gray(`     • ${name}`));
+      }
+    }
+
+    if (created.length === 0 && skipped.length > 0) {
+      console.log(chalk.green('\n  ✅ All integration files already exist. Nothing to generate.\n'));
+    } else {
+      console.log(chalk.cyan('\n  🎉 Scaffold complete!\n'));
+    }
+
+    console.log(chalk.gray('  Next steps:'));
+    console.log(chalk.gray('     • Import the L4YERCAK3 client: import { l4yercak3 } from "@/lib/l4yercak3"'));
+    console.log(chalk.gray('     • Run "l4yercak3 sync" after changing your project structure\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);
+  }
+}
+
+/**
+ * Generate the L4YERCAK3 client wrapper
+ */
+function generateClientWrapper(manifest, isTypeScript) {
+  const mappings = manifest.suggestedMappings || [];
+  const hasContact = mappings.some(m => m.platformType === 'contact');
+  const hasBooking = mappings.some(m => m.platformType === 'booking');
+  const hasEvent = mappings.some(m => m.platformType === 'event');
+  const hasProduct = mappings.some(m => m.platformType === 'product');
+
+  const typeAnnotation = isTypeScript ? ': string' : '';
+  const typeImport = isTypeScript
+    ? `import type { L4yercak3Config } from '@/types/l4yercak3';\n\n`
+    : '';
+
+  return `/**
+ * L4YERCAK3 API Client
+ * ${GENERATED_HEADER}
+ *
+ * Usage: import { l4yercak3 } from '@/lib/l4yercak3';
+ */
+
+${typeImport}const API_KEY${typeAnnotation} = process.env.L4YERCAK3_API_KEY || '';
+const BASE_URL${typeAnnotation} = process.env.L4YERCAK3_BACKEND_URL || 'https://agreeable-lion-828.convex.site';
+const ORG_ID${typeAnnotation} = process.env.L4YERCAK3_ORG_ID || '';
+const APP_ID${typeAnnotation} = process.env.L4YERCAK3_APP_ID || '';
+
+class L4yercak3Client {
+  constructor() {
+    this.apiKey = API_KEY;
+    this.baseUrl = BASE_URL;
+    this.orgId = ORG_ID;
+    this.appId = APP_ID;
+  }
+
+  async request(method${typeAnnotation ? ': string' : ''}, endpoint${typeAnnotation ? ': string' : ''}, data${isTypeScript ? '?: Record<string, unknown>' : ''}) {
+    const url = \`\${this.baseUrl}\${endpoint}\`;
+    const headers${isTypeScript ? ': Record<string, string>' : ''} = {
+      'Content-Type': 'application/json',
+      'Authorization': \`Bearer \${this.apiKey}\`,
+      'X-Organization-Id': this.orgId,
+      'X-Application-Id': this.appId,
+    };
+
+    const options${isTypeScript ? ': RequestInit' : ''} = { method, headers };
+    if (data && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+      options.body = JSON.stringify(data);
+    }
+
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(error.message || \`API error: \${response.status}\`);
+    }
+    return response.json();
+  }
+${hasContact ? `
+  // Contact methods
+  async getContacts() {
+    return this.request('GET', '/api/v1/contacts');
+  }
+
+  async createContact(data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('POST', '/api/v1/contacts', data);
+  }
+` : ''}${hasBooking ? `
+  // Booking methods
+  async getBookings() {
+    return this.request('GET', '/api/v1/bookings');
+  }
+
+  async createBooking(data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('POST', '/api/v1/bookings', data);
+  }
+` : ''}${hasEvent ? `
+  // Event methods
+  async getEvents() {
+    return this.request('GET', '/api/v1/events');
+  }
+
+  async createEvent(data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('POST', '/api/v1/events', data);
+  }
+` : ''}${hasProduct ? `
+  // Product methods
+  async getProducts() {
+    return this.request('GET', '/api/v1/products');
+  }
+
+  async createProduct(data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('POST', '/api/v1/products', data);
+  }
+` : ''}
+  // Generic resource methods
+  async get(resource${typeAnnotation ? ': string' : ''}) {
+    return this.request('GET', \`/api/v1/\${resource}\`);
+  }
+
+  async create(resource${typeAnnotation ? ': string' : ''}, data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('POST', \`/api/v1/\${resource}\`, data);
+  }
+
+  async update(resource${typeAnnotation ? ': string' : ''}, id${typeAnnotation ? ': string' : ''}, data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('PATCH', \`/api/v1/\${resource}/\${id}\`, data);
+  }
+
+  async remove(resource${typeAnnotation ? ': string' : ''}, id${typeAnnotation ? ': string' : ''}) {
+    return this.request('DELETE', \`/api/v1/\${resource}/\${id}\`);
+  }
+}
+
+export const l4yercak3 = new L4yercak3Client();
+export default l4yercak3;
+`;
+}
+
+/**
+ * Generate webhook handler
+ */
+function generateWebhookHandler(manifest, isTypeScript, routerType) {
+  if (routerType === 'app') {
+    return `/**
+ * L4YERCAK3 Webhook Handler (App Router)
+ * ${GENERATED_HEADER}
+ *
+ * Receives webhook events from the L4YERCAK3 platform.
+ * Configure your webhook URL in the L4YERCAK3 dashboard.
+ */
+
+import { NextResponse } from 'next/server';
+
+export async function POST(request${isTypeScript ? ': Request' : ''}) {
+  try {
+    const body = await request.json();
+    const eventType = body.type;
+
+    // Verify webhook signature (recommended for production)
+    // const signature = request.headers.get('x-l4yercak3-signature');
+
+    switch (eventType) {
+      case 'contact.created':
+      case 'contact.updated':
+        // Handle contact events
+        console.log(\`[L4YERCAK3] \${eventType}:\`, body.data);
+        break;
+
+      case 'booking.created':
+      case 'booking.updated':
+        // Handle booking events
+        console.log(\`[L4YERCAK3] \${eventType}:\`, body.data);
+        break;
+
+      default:
+        console.log(\`[L4YERCAK3] Unhandled event: \${eventType}\`);
+    }
+
+    return NextResponse.json({ received: true });
+  } catch (error) {
+    console.error('[L4YERCAK3] Webhook error:', error);
+    return NextResponse.json({ error: 'Webhook processing failed' }, { status: 500 });
+  }
+}
+`;
+  }
+
+  // Pages Router
+  return `/**
+ * L4YERCAK3 Webhook Handler (Pages Router)
+ * ${GENERATED_HEADER}
+ *
+ * Receives webhook events from the L4YERCAK3 platform.
+ * Configure your webhook URL in the L4YERCAK3 dashboard.
+ */
+
+export default async function handler(req, res) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  try {
+    const body = req.body;
+    const eventType = body.type;
+
+    // Verify webhook signature (recommended for production)
+    // const signature = req.headers['x-l4yercak3-signature'];
+
+    switch (eventType) {
+      case 'contact.created':
+      case 'contact.updated':
+        // Handle contact events
+        console.log(\`[L4YERCAK3] \${eventType}:\`, body.data);
+        break;
+
+      case 'booking.created':
+      case 'booking.updated':
+        // Handle booking events
+        console.log(\`[L4YERCAK3] \${eventType}:\`, body.data);
+        break;
+
+      default:
+        console.log(\`[L4YERCAK3] Unhandled event: \${eventType}\`);
+    }
+
+    return res.status(200).json({ received: true });
+  } catch (error) {
+    console.error('[L4YERCAK3] Webhook error:', error);
+    return res.status(500).json({ error: 'Webhook processing failed' });
+  }
+}
+`;
+}
+
+/**
+ * Generate TypeScript types based on manifest models and mappings
+ */
+function generateTypes(manifest) {
+  const models = manifest.detectedModels || [];
+  const mappings = manifest.suggestedMappings || [];
+
+  let content = `/**
+ * L4YERCAK3 Types
+ * ${GENERATED_HEADER}
+ *
+ * Types generated from your project's detected models and platform mappings.
+ */
+
+export interface L4yercak3Config {
+  apiKey: string;
+  baseUrl: string;
+  orgId: string;
+  appId: string;
+}
+
+export interface WebhookEvent {
+  type: string;
+  data: Record<string, unknown>;
+  timestamp: number;
+  applicationId: string;
+}
+
+`;
+
+  // Generate interfaces for each mapping
+  for (const mapping of mappings) {
+    const model = models.find(m => m.name === mapping.localModel);
+    if (model) {
+      content += `/**
+ * Platform mapping: ${model.name} → ${mapping.platformType} (${mapping.confidence}% confidence)
+ * Source: ${model.source}
+ */
+export interface ${model.name}Mapping {
+`;
+      for (const field of model.fields) {
+        content += `  ${field}: unknown;\n`;
+      }
+      content += `  // Platform fields
+  _platformType: '${mapping.platformType}';
+  _platformId?: string;
+}\n\n`;
+    }
+  }
+
+  // Generate union type of all platform types used
+  const platformTypes = [...new Set(mappings.map(m => m.platformType))];
+  if (platformTypes.length > 0) {
+    content += `export type PlatformType = ${platformTypes.map(t => `'${t}'`).join(' | ')};\n`;
+  }
+
+  return content;
+}
+
+module.exports = {
+  command: 'scaffold',
+  description: 'Generate integration files based on your project manifest',
+  handler: handleScaffold,
+};

package/src/commands/spread.js

@@ -5,181 +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) {
-  // 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()) {
-    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'));
 
@@ -276,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
@@ -705,6 +590,15 @@ async function handleSpread() {
       selectedDatabase,
     };
 
+    // Debug: Log generation options
+    if (process.env.L4YERCAK3_DEBUG) {
+      console.log('\n[DEBUG] Spread: Generation options:');
+      console.log(`  frameworkType: "${generationOptions.frameworkType}"`);
+      console.log(`  integrationPath: "${generationOptions.integrationPath}"`);
+      console.log(`  isTypeScript: ${generationOptions.isTypeScript}`);
+      console.log(`  features: [${generationOptions.features.join(', ')}]`);
+    }
+
     const generatedFiles = await fileGenerator.generate(generationOptions);
 
     // Display results
@@ -746,6 +640,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'));