@l4yercak3/cli 1.2.20 → 1.3.0

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,
+};

package/src/detectors/model-detector.js

@@ -0,0 +1,318 @@
+/**
+ * Model/Type Scanner
+ * Detects data models and types across multiple sources:
+ * - Prisma schemas
+ * - TypeScript interfaces/types
+ * - Drizzle table definitions
+ * - Convex schemas
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * @typedef {Object} DetectedModel
+ * @property {string} name - Model name
+ * @property {string} source - Source identifier (e.g., 'prisma/schema.prisma')
+ * @property {string[]} fields - Field names
+ */
+
+/**
+ * Check if a path exists
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function exists(filePath) {
+  try {
+    return fs.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Safely read a file
+ * @param {string} filePath
+ * @returns {string|null}
+ */
+function readFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Find files matching a pattern in a directory (non-recursive)
+ * @param {string} dir
+ * @param {RegExp} pattern
+ * @returns {string[]}
+ */
+function findFiles(dir, pattern) {
+  if (!exists(dir)) return [];
+  try {
+    return fs.readdirSync(dir)
+      .filter(f => pattern.test(f))
+      .map(f => path.join(dir, f));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Parse Prisma schema file for model definitions
+ * @param {string} filePath - Path to schema.prisma
+ * @returns {DetectedModel[]}
+ */
+function parsePrismaSchema(filePath) {
+  const content = readFile(filePath);
+  if (!content) return [];
+
+  const models = [];
+  const modelRegex = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
+  let match;
+
+  while ((match = modelRegex.exec(content)) !== null) {
+    const name = match[1];
+    const body = match[2];
+    const fields = [];
+
+    for (const line of body.split('\n')) {
+      const trimmed = line.trim();
+      // Skip empty lines, comments, and @@ annotations
+      if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('@@')) continue;
+      // Extract field name (first word on the line)
+      const fieldMatch = trimmed.match(/^(\w+)\s+/);
+      if (fieldMatch) {
+        fields.push(fieldMatch[1]);
+      }
+    }
+
+    models.push({
+      name,
+      source: 'prisma/schema.prisma',
+      fields,
+    });
+  }
+
+  return models;
+}
+
+/**
+ * Parse TypeScript files for interface and type definitions
+ * @param {string[]} dirs - Directories to scan
+ * @param {string} projectPath - Project root for relative paths
+ * @returns {DetectedModel[]}
+ */
+function parseTypeScriptTypes(dirs, projectPath) {
+  const models = [];
+  const filePattern = /\.(ts|tsx)$/;
+
+  for (const dir of dirs) {
+    const files = findFiles(dir, filePattern);
+
+    for (const filePath of files) {
+      const content = readFile(filePath);
+      if (!content) continue;
+
+      const relativePath = path.relative(projectPath, filePath);
+
+      // Match interface declarations
+      const interfaceRegex = /^(?:export\s+)?interface\s+(\w+)\s*(?:extends\s+[\w,\s<>]+)?\s*\{([^}]+)\}/gm;
+      let match;
+
+      while ((match = interfaceRegex.exec(content)) !== null) {
+        const name = match[1];
+        const body = match[2];
+        const fields = extractTsFields(body);
+        if (fields.length > 0) {
+          models.push({ name, source: relativePath, fields });
+        }
+      }
+
+      // Match type aliases with object shapes
+      const typeRegex = /^(?:export\s+)?type\s+(\w+)\s*=\s*\{([^}]+)\}/gm;
+      while ((match = typeRegex.exec(content)) !== null) {
+        const name = match[1];
+        const body = match[2];
+        const fields = extractTsFields(body);
+        if (fields.length > 0) {
+          models.push({ name, source: relativePath, fields });
+        }
+      }
+    }
+  }
+
+  return models;
+}
+
+/**
+ * Extract field names from a TypeScript object body
+ * @param {string} body
+ * @returns {string[]}
+ */
+function extractTsFields(body) {
+  const fields = [];
+  for (const line of body.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('/*')) continue;
+    // Match: fieldName: type or fieldName?: type
+    const fieldMatch = trimmed.match(/^(\w+)\s*\??:/);
+    if (fieldMatch) {
+      fields.push(fieldMatch[1]);
+    }
+  }
+  return fields;
+}
+
+/**
+ * Parse Drizzle schema files for table definitions
+ * @param {string[]} dirs - Directories to scan
+ * @param {string} projectPath - Project root for relative paths
+ * @returns {DetectedModel[]}
+ */
+function parseDrizzleSchemas(dirs, projectPath) {
+  const models = [];
+  const filePattern = /schema.*\.(ts|js)$/;
+
+  for (const dir of dirs) {
+    const files = findFiles(dir, filePattern);
+
+    for (const filePath of files) {
+      const content = readFile(filePath);
+      if (!content) continue;
+
+      const relativePath = path.relative(projectPath, filePath);
+
+      // Match: export const tableName = pgTable('table_name', { ... })
+      const tableRegex = /export\s+const\s+(\w+)\s*=\s*(?:pgTable|mysqlTable|sqliteTable)\s*\(\s*['"](\w+)['"]\s*,\s*\{([^}]+)\}/g;
+      let match;
+
+      while ((match = tableRegex.exec(content)) !== null) {
+        // match[1] is the variable name (e.g., 'users'), match[2] is the SQL table name
+        const tableName = match[2];
+        const body = match[3];
+        const fields = [];
+
+        for (const line of body.split('\n')) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith('//')) continue;
+          // Match: columnName: type(...)
+          const colMatch = trimmed.match(/^(\w+)\s*:/);
+          if (colMatch) {
+            fields.push(colMatch[1]);
+          }
+        }
+
+        // Use PascalCase version of table name as model name
+        const name = tableName
+          .split('_')
+          .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+          .join('');
+
+        models.push({ name, source: relativePath, fields });
+      }
+    }
+  }
+
+  return models;
+}
+
+/**
+ * Parse Convex schema file
+ * @param {string} filePath - Path to convex/schema.ts
+ * @param {string} projectPath - Project root
+ * @returns {DetectedModel[]}
+ */
+function parseConvexSchema(filePath, projectPath) {
+  const content = readFile(filePath);
+  if (!content) return [];
+
+  const models = [];
+  const relativePath = path.relative(projectPath, filePath);
+
+  // Match: tableName: defineTable({ ... })
+  const tableRegex = /(\w+)\s*:\s*defineTable\s*\(\s*\{([^}]+)\}/g;
+  let match;
+
+  while ((match = tableRegex.exec(content)) !== null) {
+    const tableName = match[1];
+    const body = match[2];
+    const fields = [];
+
+    for (const line of body.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('//')) continue;
+      const fieldMatch = trimmed.match(/^(\w+)\s*:/);
+      if (fieldMatch) {
+        fields.push(fieldMatch[1]);
+      }
+    }
+
+    const name = tableName.charAt(0).toUpperCase() + tableName.slice(1);
+    models.push({ name, source: relativePath, fields });
+  }
+
+  return models;
+}
+
+/**
+ * Detect all models/types in a project
+ * @param {string} projectPath - Project root path
+ * @returns {{ hasModels: boolean, models: DetectedModel[] }}
+ */
+function detect(projectPath = process.cwd()) {
+  const allModels = [];
+
+  // 1. Prisma
+  const prismaPath = path.join(projectPath, 'prisma', 'schema.prisma');
+  if (exists(prismaPath)) {
+    allModels.push(...parsePrismaSchema(prismaPath));
+  }
+
+  // 2. TypeScript types/interfaces
+  const tsDirs = [
+    path.join(projectPath, 'types'),
+    path.join(projectPath, 'src', 'types'),
+    path.join(projectPath, 'models'),
+    path.join(projectPath, 'src', 'models'),
+  ].filter(d => exists(d));
+
+  if (tsDirs.length > 0) {
+    allModels.push(...parseTypeScriptTypes(tsDirs, projectPath));
+  }
+
+  // 3. Drizzle
+  const drizzleDirs = [
+    path.join(projectPath, 'drizzle'),
+    path.join(projectPath, 'src', 'db'),
+    path.join(projectPath, 'db'),
+  ].filter(d => exists(d));
+
+  if (drizzleDirs.length > 0) {
+    allModels.push(...parseDrizzleSchemas(drizzleDirs, projectPath));
+  }
+
+  // 4. Convex
+  const convexSchemaTs = path.join(projectPath, 'convex', 'schema.ts');
+  const convexSchemaJs = path.join(projectPath, 'convex', 'schema.js');
+  if (exists(convexSchemaTs)) {
+    allModels.push(...parseConvexSchema(convexSchemaTs, projectPath));
+  } else if (exists(convexSchemaJs)) {
+    allModels.push(...parseConvexSchema(convexSchemaJs, projectPath));
+  }
+
+  return {
+    hasModels: allModels.length > 0,
+    models: allModels,
+  };
+}
+
+module.exports = {
+  detect,
+  parsePrismaSchema,
+  parseTypeScriptTypes,
+  parseDrizzleSchemas,
+  parseConvexSchema,
+};