@l4yercak3/cli 1.3.2 → 2.0.0-alpha.1

package/src/detectors/database-detector.js

@@ -1,245 +0,0 @@
-/**
- * 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

@@ -1,166 +0,0 @@
-/**
- * Expo/React Native Project Detector
- * Detects Expo and React Native projects and their configuration
- */
-
-const fs = require('fs');
-const path = require('path');
-const BaseDetector = require('./base-detector');
-
-class ExpoDetector extends BaseDetector {
-  get name() {
-    return 'expo';
-  }
-
-  get priority() {
-    return 95; // Slightly lower than Next.js (100), but high enough for framework detection
-  }
-
-  /**
-   * Detect if current directory is an Expo or React Native project
-   */
-  detect(projectPath = process.cwd()) {
-    const results = {
-      isExpo: false,
-      isReactNative: false,
-      expoVersion: null,
-      reactNativeVersion: null,
-      hasTypeScript: false,
-      routerType: null, // 'expo-router' or 'react-navigation' or null
-      sdkVersion: null,
-      config: null,
-    };
-
-    // Check for package.json
-    const packageJsonPath = path.join(projectPath, 'package.json');
-    if (!fs.existsSync(packageJsonPath)) {
-      return {
-        detected: false,
-        confidence: 0,
-        metadata: {},
-      };
-    }
-
-    try {
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-      const dependencies = {
-        ...packageJson.dependencies,
-        ...packageJson.devDependencies,
-      };
-
-      // Check for Expo
-      if (dependencies.expo) {
-        results.isExpo = true;
-        results.expoVersion = dependencies.expo;
-      }
-
-      // Check for React Native (with or without Expo)
-      if (dependencies['react-native']) {
-        results.isReactNative = true;
-        results.reactNativeVersion = dependencies['react-native'];
-      }
-
-      // If neither, not a React Native project
-      if (!results.isExpo && !results.isReactNative) {
-        return {
-          detected: false,
-          confidence: 0,
-          metadata: {},
-        };
-      }
-
-      // Check for TypeScript
-      if (dependencies.typescript || fs.existsSync(path.join(projectPath, 'tsconfig.json'))) {
-        results.hasTypeScript = true;
-      }
-
-      // Detect router type
-      // Default to 'native' (no file-based router) if no router package is found
-      if (dependencies['expo-router']) {
-        results.routerType = 'expo-router';
-      } else if (dependencies['@react-navigation/native']) {
-        results.routerType = 'react-navigation';
-      } else {
-        results.routerType = 'native'; // Basic React Native navigation
-      }
-
-      // Check for app.json or app.config.js (Expo config)
-      const appJsonPath = path.join(projectPath, 'app.json');
-      const appConfigJsPath = path.join(projectPath, 'app.config.js');
-      const appConfigTsPath = path.join(projectPath, 'app.config.ts');
-
-      if (fs.existsSync(appJsonPath)) {
-        try {
-          const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf8'));
-          results.config = 'app.json';
-          if (appJson.expo?.sdkVersion) {
-            results.sdkVersion = appJson.expo.sdkVersion;
-          }
-        } catch (error) {
-          // Could not parse app.json
-        }
-      } else if (fs.existsSync(appConfigJsPath)) {
-        results.config = 'app.config.js';
-      } else if (fs.existsSync(appConfigTsPath)) {
-        results.config = 'app.config.ts';
-      }
-
-      // Determine confidence based on what we found
-      let confidence = 0.85; // Base confidence for React Native
-      if (results.isExpo) {
-        confidence = 0.9; // Higher confidence for Expo projects
-        if (results.config) {
-          confidence = 0.95; // Even higher with config file (app.json)
-        }
-      }
-
-      return {
-        detected: true,
-        confidence,
-        metadata: {
-          isExpo: results.isExpo,
-          expoVersion: results.expoVersion,
-          reactNativeVersion: results.reactNativeVersion,
-          hasTypeScript: results.hasTypeScript,
-          routerType: results.routerType,
-          sdkVersion: results.sdkVersion,
-          config: results.config,
-        },
-      };
-    } catch (error) {
-      // Error reading package.json
-      return {
-        detected: false,
-        confidence: 0,
-        metadata: {},
-      };
-    }
-  }
-
-  /**
-   * Get supported features for Expo/React Native
-   */
-  getSupportedFeatures() {
-    return {
-      oauth: true,      // OAuth via expo-auth-session or similar
-      stripe: true,     // Stripe via @stripe/stripe-react-native
-      crm: true,        // CRM API access
-      projects: true,   // Projects API access
-      invoices: true,   // Invoices API access
-    };
-  }
-
-  /**
-   * Get available generators for Expo/React Native
-   */
-  getAvailableGenerators() {
-    return [
-      'api-client',    // TypeScript API client
-      'env',           // Environment variables
-      'oauth-guide',   // OAuth setup guide for mobile
-      // Future: 'expo-auth', 'stripe-mobile'
-    ];
-  }
-}
-
-module.exports = new ExpoDetector();

package/src/detectors/github-detector.js

@@ -1,74 +0,0 @@
-/**
- * GitHub Repository Detector
- * Detects GitHub repository information from git remotes
- */
-
-const { execSync } = require('child_process');
-const path = require('path');
-
-class GitHubDetector {
-  /**
-   * Detect GitHub repository information
-   */
-  detect(projectPath = process.cwd()) {
-    const results = {
-      hasGit: false,
-      isGitHub: false,
-      owner: null,
-      repo: null,
-      url: null,
-      branch: null,
-    };
-
-    // Check if .git directory exists
-    const gitDir = path.join(projectPath, '.git');
-    if (!require('fs').existsSync(gitDir)) {
-      return results;
-    }
-
-    results.hasGit = true;
-
-    try {
-      // Get git remote URL
-      const remoteUrl = execSync('git config --get remote.origin.url', {
-        cwd: projectPath,
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'ignore'],
-      }).trim();
-
-      if (!remoteUrl) {
-        return results;
-      }
-
-      // Parse GitHub URL (supports both HTTPS and SSH formats)
-      // https://github.com/owner/repo.git
-      // git@github.com:owner/repo.git
-      const githubMatch = remoteUrl.match(/github\.com[/:]([^/]+)\/([^/]+?)(?:\.git)?$/);
-      
-      if (githubMatch) {
-        results.isGitHub = true;
-        results.owner = githubMatch[1];
-        results.repo = githubMatch[2].replace(/\.git$/, '');
-        results.url = `https://github.com/${results.owner}/${results.repo}`;
-      }
-
-      // Get current branch
-      try {
-        const branch = execSync('git rev-parse --abbrev-ref HEAD', {
-          cwd: projectPath,
-          encoding: 'utf8',
-          stdio: ['pipe', 'pipe', 'ignore'],
-        }).trim();
-        results.branch = branch;
-      } catch (error) {
-        // Couldn't get branch
-      }
-    } catch (error) {
-      // Error reading git config
-    }
-
-    return results;
-  }
-}
-
-module.exports = new GitHubDetector();

package/src/detectors/index.js

@@ -1,106 +0,0 @@
-/**
- * Project Detectors
- * Main entry point for all project detection
- * 
- * This module orchestrates both framework detection (Next.js, React, etc.)
- * and project metadata detection (GitHub, API clients, etc.)
- */
-
-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');
-const modelDetector = require('./model-detector');
-
-class ProjectDetector {
-  /**
-   * Run all detectors and return combined results
-   * 
-   * @param {string} projectPath - Path to project directory
-   * @returns {object} Combined detection results
-   */
-  detect(projectPath = process.cwd()) {
-    // Detect framework/project type
-    const frameworkDetection = registry.detectProjectType(projectPath);
-    
-    // Detect project metadata (framework-agnostic)
-    const githubInfo = githubDetector.detect(projectPath);
-    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
-      ? registry.getDetector(frameworkDetection.detected)
-      : null;
-
-    return {
-      // Framework detection
-      framework: {
-        type: frameworkDetection.detected,
-        confidence: frameworkDetection.confidence,
-        metadata: frameworkDetection.metadata,
-        supportedFeatures: detector?.getSupportedFeatures() || {},
-        availableGenerators: detector?.getAvailableGenerators() || [],
-      },
-
-      // Project metadata (framework-agnostic)
-      github: githubInfo,
-      apiClient: apiClientInfo,
-      oauth: oauthInfo,
-      database: databaseInfo,
-      models: modelInfo,
-
-      // Raw detection results (for debugging)
-      _raw: {
-        frameworkResults: frameworkDetection.allResults,
-      },
-
-      // Project path
-      projectPath,
-    };
-  }
-
-  /**
-   * 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
-   *
-   * @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
-   * 
-   * @param {string} type - Project type name (e.g., 'nextjs')
-   * @returns {object|null} Detector instance or null
-   */
-  getDetector(type) {
-    return registry.getDetector(type);
-  }
-
-  /**
-   * Get all available project types
-   * 
-   * @returns {array} Array of detector names
-   */
-  getAvailableTypes() {
-    return registry.getAllDetectors().map(d => d.name);
-  }
-}
-
-module.exports = new ProjectDetector();

package/src/detectors/mapping-suggestor.js

@@ -1,119 +0,0 @@
-/**
- * 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,
-};