@l4yercak3/cli 1.2.20 → 1.3.0

package/src/detectors/page-detector.js

@@ -0,0 +1,480 @@
+/**
+ * Page/Screen Detector
+ * Detects pages in Next.js projects and screens in Expo/React Native projects
+ * Used for syncing application structure with L4YERCAK3 backend
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class PageDetector {
+  /**
+   * Detect all pages/screens in a project
+   * @param {string} projectPath - Path to project root
+   * @param {string} frameworkType - 'nextjs', 'expo', or 'react-native'
+   * @param {object} frameworkMetadata - Additional framework info (routerType, etc.)
+   * @returns {Array<{path: string, name: string, pageType: string, filePath: string}>}
+   */
+  detect(projectPath, frameworkType, frameworkMetadata = {}) {
+    switch (frameworkType) {
+      case 'nextjs':
+        return this.detectNextJsPages(projectPath, frameworkMetadata);
+      case 'expo':
+      case 'react-native':
+        return this.detectExpoScreens(projectPath, frameworkMetadata);
+      default:
+        return [];
+    }
+  }
+
+  /**
+   * Detect Next.js pages (supports both App Router and Pages Router)
+   */
+  detectNextJsPages(projectPath, metadata) {
+    const routerType = metadata.routerType || 'pages';
+    const pages = [];
+
+    if (routerType === 'app') {
+      // App Router: look for page.tsx/page.js files in app/ or src/app/
+      const appDirs = [
+        path.join(projectPath, 'app'),
+        path.join(projectPath, 'src', 'app'),
+      ];
+
+      for (const appDir of appDirs) {
+        if (fs.existsSync(appDir)) {
+          this.scanAppRouterDirectory(appDir, '', pages, appDir);
+          break; // Only use the first found app directory
+        }
+      }
+    } else {
+      // Pages Router: look for files in pages/ or src/pages/
+      const pagesDirs = [
+        path.join(projectPath, 'pages'),
+        path.join(projectPath, 'src', 'pages'),
+      ];
+
+      for (const pagesDir of pagesDirs) {
+        if (fs.existsSync(pagesDir)) {
+          this.scanPagesRouterDirectory(pagesDir, '', pages, pagesDir);
+          break;
+        }
+      }
+    }
+
+    return pages;
+  }
+
+  /**
+   * Scan App Router directory structure
+   * In App Router, pages are defined by page.tsx/page.js files
+   * API routes are defined by route.tsx/route.js files
+   */
+  scanAppRouterDirectory(dir, routePath, pages, baseDir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Skip special directories
+        if (entry.name.startsWith('_') || entry.name.startsWith('.')) {
+          continue;
+        }
+
+        // Handle route groups (parentheses) - they don't add to URL
+        let newRoutePath = routePath;
+        if (!entry.name.startsWith('(') || !entry.name.endsWith(')')) {
+          // Handle dynamic segments [param] and catch-all [...param]
+          let segment = entry.name;
+          if (segment.startsWith('[') && segment.endsWith(']')) {
+            // Keep dynamic segment notation
+            newRoutePath = `${routePath}/${segment}`;
+          } else {
+            newRoutePath = `${routePath}/${segment}`;
+          }
+        }
+
+        this.scanAppRouterDirectory(fullPath, newRoutePath, pages, baseDir);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        const baseName = path.basename(entry.name, ext);
+
+        // Check for page files
+        if (baseName === 'page' && ['.tsx', '.ts', '.jsx', '.js'].includes(ext)) {
+          const pagePath = routePath || '/';
+          pages.push({
+            path: pagePath,
+            name: this.generatePageName(pagePath),
+            pageType: this.detectPageType(pagePath),
+            filePath: path.relative(baseDir, fullPath),
+          });
+        }
+
+        // Check for API route files
+        if (baseName === 'route' && ['.tsx', '.ts', '.jsx', '.js'].includes(ext)) {
+          const apiPath = routePath || '/';
+          const methods = this.detectHttpMethods(fullPath, 'app');
+          pages.push({
+            path: apiPath,
+            name: this.generatePageName(apiPath, true),
+            pageType: 'api_route',
+            filePath: path.relative(baseDir, fullPath),
+            methods,
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Detect HTTP methods exported from a route file
+   * @param {string} filePath - Absolute path to the route file
+   * @param {string} routerType - 'app' or 'pages'
+   * @returns {string[]} Array of HTTP methods (e.g., ['GET', 'POST'])
+   */
+  detectHttpMethods(filePath, routerType) {
+    let content;
+    try {
+      content = fs.readFileSync(filePath, 'utf8');
+    } catch {
+      return ['GET', 'POST']; // Default fallback
+    }
+
+    const methods = new Set();
+
+    if (routerType === 'app') {
+      // App Router: look for exported handler functions
+      // export async function GET(...) or export const GET = ...
+      const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+      for (const method of HTTP_METHODS) {
+        const funcPattern = new RegExp(`export\\s+(?:async\\s+)?function\\s+${method}\\b`);
+        const constPattern = new RegExp(`export\\s+const\\s+${method}\\s*=`);
+        if (funcPattern.test(content) || constPattern.test(content)) {
+          methods.add(method);
+        }
+      }
+    } else {
+      // Pages Router: look for req.method checks
+      const methodCheckRegex = /req\.method\s*===?\s*['"](\w+)['"]/g;
+      let match;
+      while ((match = methodCheckRegex.exec(content)) !== null) {
+        methods.add(match[1].toUpperCase());
+      }
+
+      // Also check switch/case patterns: case 'GET':
+      const caseRegex = /case\s+['"](\w+)['"]\s*:/g;
+      while ((match = caseRegex.exec(content)) !== null) {
+        const val = match[1].toUpperCase();
+        if (['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'].includes(val)) {
+          methods.add(val);
+        }
+      }
+    }
+
+    // Default to GET/POST if no methods detected
+    if (methods.size === 0) {
+      return ['GET', 'POST'];
+    }
+
+    return Array.from(methods).sort();
+  }
+
+  /**
+   * Scan Pages Router directory structure
+   * In Pages Router, each file is a page, and files in api/ are API routes
+   */
+  scanPagesRouterDirectory(dir, routePath, pages, baseDir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Skip special directories
+        if (entry.name.startsWith('_') || entry.name.startsWith('.')) {
+          continue;
+        }
+
+        const newRoutePath = `${routePath}/${entry.name}`;
+        this.scanPagesRouterDirectory(fullPath, newRoutePath, pages, baseDir);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        const baseName = path.basename(entry.name, ext);
+
+        // Only process TypeScript/JavaScript files
+        if (!['.tsx', '.ts', '.jsx', '.js'].includes(ext)) {
+          continue;
+        }
+
+        // Skip special files
+        if (baseName.startsWith('_')) {
+          continue;
+        }
+
+        // Determine the route path
+        let pagePath;
+        if (baseName === 'index') {
+          pagePath = routePath || '/';
+        } else {
+          pagePath = `${routePath}/${baseName}`;
+        }
+
+        // Check if this is an API route
+        const isApiRoute = routePath.startsWith('/api') || pagePath.startsWith('/api');
+
+        const entry_data = {
+          path: pagePath,
+          name: this.generatePageName(pagePath, isApiRoute),
+          pageType: isApiRoute ? 'api_route' : this.detectPageType(pagePath),
+          filePath: path.relative(baseDir, fullPath),
+        };
+
+        if (isApiRoute) {
+          entry_data.methods = this.detectHttpMethods(fullPath, 'pages');
+        }
+
+        pages.push(entry_data);
+      }
+    }
+  }
+
+  /**
+   * Detect Expo/React Native screens
+   * Supports expo-router (file-based) and react-navigation
+   */
+  detectExpoScreens(projectPath, metadata) {
+    const screens = [];
+    const routerType = metadata.routerType || 'native';
+
+    if (routerType === 'expo-router') {
+      // Expo Router uses file-based routing similar to Next.js App Router
+      const appDirs = [
+        path.join(projectPath, 'app'),
+        path.join(projectPath, 'src', 'app'),
+      ];
+
+      for (const appDir of appDirs) {
+        if (fs.existsSync(appDir)) {
+          this.scanExpoRouterDirectory(appDir, '', screens, appDir);
+          break;
+        }
+      }
+    } else {
+      // React Navigation or native - scan for screen files
+      const screenDirs = [
+        path.join(projectPath, 'src', 'screens'),
+        path.join(projectPath, 'screens'),
+        path.join(projectPath, 'src', 'views'),
+        path.join(projectPath, 'views'),
+        path.join(projectPath, 'app', 'screens'),
+      ];
+
+      for (const screenDir of screenDirs) {
+        if (fs.existsSync(screenDir)) {
+          this.scanScreensDirectory(screenDir, screens, screenDir);
+        }
+      }
+    }
+
+    return screens;
+  }
+
+  /**
+   * Scan Expo Router directory structure
+   * Similar to Next.js App Router but with some differences
+   */
+  scanExpoRouterDirectory(dir, routePath, screens, baseDir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Skip special directories
+        if (entry.name.startsWith('_') || entry.name.startsWith('.')) {
+          continue;
+        }
+
+        // Handle route groups (parentheses)
+        let newRoutePath = routePath;
+        if (!entry.name.startsWith('(') || !entry.name.endsWith(')')) {
+          newRoutePath = `${routePath}/${entry.name}`;
+        }
+
+        this.scanExpoRouterDirectory(fullPath, newRoutePath, screens, baseDir);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        const baseName = path.basename(entry.name, ext);
+
+        // Skip non-JS/TS files and special files
+        if (!['.tsx', '.ts', '.jsx', '.js'].includes(ext)) {
+          continue;
+        }
+        if (baseName.startsWith('_')) {
+          continue;
+        }
+
+        // Determine the route path
+        let screenPath;
+        if (baseName === 'index') {
+          screenPath = routePath || '/';
+        } else if (baseName === '+not-found') {
+          screenPath = '/*'; // Catch-all not found
+        } else if (baseName.startsWith('+')) {
+          // Skip Expo Router special files like +html.tsx, +native-intent.tsx
+          continue;
+        } else {
+          screenPath = `${routePath}/${baseName}`;
+        }
+
+        screens.push({
+          path: screenPath,
+          name: this.generatePageName(screenPath),
+          pageType: this.detectPageType(screenPath),
+          filePath: path.relative(baseDir, fullPath),
+        });
+      }
+    }
+  }
+
+  /**
+   * Scan traditional screens directory for React Navigation setup
+   */
+  scanScreensDirectory(dir, screens, baseDir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Recurse into subdirectories
+        this.scanScreensDirectory(fullPath, screens, baseDir);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        const baseName = path.basename(entry.name, ext);
+
+        // Only process screen files
+        if (!['.tsx', '.ts', '.jsx', '.js'].includes(ext)) {
+          continue;
+        }
+
+        // Skip index files and non-screen files
+        if (baseName === 'index' || baseName.startsWith('_')) {
+          continue;
+        }
+
+        // Try to extract a meaningful path from the file name
+        // e.g., HomeScreen.tsx -> /home, ProfileScreen.tsx -> /profile
+        let screenPath = this.fileNameToPath(baseName);
+
+        screens.push({
+          path: screenPath,
+          name: this.generatePageName(screenPath),
+          pageType: 'static',
+          filePath: path.relative(baseDir, fullPath),
+        });
+      }
+    }
+  }
+
+  /**
+   * Convert a file name to a route path
+   * e.g., "HomeScreen" -> "/home", "UserProfileScreen" -> "/user-profile"
+   */
+  fileNameToPath(fileName) {
+    // Remove common suffixes
+    let name = fileName
+      .replace(/Screen$/, '')
+      .replace(/View$/, '')
+      .replace(/Page$/, '');
+
+    // Convert camelCase/PascalCase to kebab-case
+    name = name
+      .replace(/([a-z])([A-Z])/g, '$1-$2')
+      .toLowerCase();
+
+    // Handle "Home" or "Index" specially
+    if (name === 'home' || name === 'index' || name === 'main') {
+      return '/';
+    }
+
+    return `/${name}`;
+  }
+
+  /**
+   * Generate a human-readable name from a path
+   */
+  generatePageName(routePath, isApiRoute = false) {
+    if (routePath === '/') {
+      return isApiRoute ? 'API: Root' : 'Home';
+    }
+
+    // Handle catch-all not found (Expo +not-found)
+    if (routePath === '/*') {
+      return 'Not Found';
+    }
+
+    // Remove leading slash and split
+    const segments = routePath.slice(1).split('/');
+
+    // Handle API routes
+    if (isApiRoute || segments[0] === 'api') {
+      const apiSegments = segments.filter(s => s !== 'api');
+      if (apiSegments.length === 0) {
+        return 'API: Root';
+      }
+      const name = this.formatSegment(apiSegments[apiSegments.length - 1]);
+      return `API: ${name}`;
+    }
+
+    // Get the last segment for the name
+    const lastSegment = segments[segments.length - 1];
+
+    // Check if it's a dynamic segment
+    if (lastSegment.startsWith('[') && lastSegment.endsWith(']')) {
+      // Use the parent segment + "Detail"
+      if (segments.length > 1) {
+        const parentSegment = segments[segments.length - 2];
+        return `${this.formatSegment(parentSegment)} Detail`;
+      }
+      return 'Detail';
+    }
+
+    // Check for catch-all
+    if (lastSegment.startsWith('[...')) {
+      return 'Catch All';
+    }
+
+    return this.formatSegment(lastSegment);
+  }
+
+  /**
+   * Format a URL segment into a readable name
+   */
+  formatSegment(segment) {
+    // Handle dynamic segments
+    if (segment.startsWith('[') && segment.endsWith(']')) {
+      segment = segment.slice(1, -1);
+    }
+
+    // Convert kebab-case to Title Case
+    return segment
+      .split('-')
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Detect page type based on path
+   */
+  detectPageType(routePath) {
+    // Check for dynamic segments
+    if (routePath.includes('[') && routePath.includes(']')) {
+      return 'dynamic';
+    }
+    return 'static';
+  }
+}
+
+module.exports = new PageDetector();

package/src/detectors/registry.js

@@ -28,10 +28,10 @@ const sortedDetectors = [...detectors].sort((a, b) => b.priority - a.priority);
 
 /**
  * Detect project type
- * 
+ *
  * Runs all detectors in priority order and returns the first match
  * with confidence > 0.8, or all results if no high-confidence match.
- * 
+ *
  * @param {string} projectPath - Path to project directory
  * @returns {object} Detection results
  */
@@ -43,11 +43,24 @@ function detectProjectType(projectPath = process.cwd()) {
     allResults: [],     // All detector results (for debugging)
   };
 
+  const debug = process.env.L4YERCAK3_DEBUG;
+
+  if (debug) {
+    console.log('\n[DEBUG] Registry: Running detectors in priority order:');
+  }
+
   // Run all detectors
   for (const detector of sortedDetectors) {
     try {
       const result = detector.detect(projectPath);
-      
+
+      if (debug) {
+        console.log(`  [${detector.name}] priority=${detector.priority}, detected=${result.detected}, confidence=${result.confidence}`);
+        if (result.metadata) {
+          console.log(`    metadata: ${JSON.stringify(result.metadata)}`);
+        }
+      }
+
       results.allResults.push({
         detector: detector.name,
         priority: detector.priority,
@@ -57,9 +70,14 @@ function detectProjectType(projectPath = process.cwd()) {
       // If this detector found a match with high confidence, use it
       if (result.detected && result.confidence > 0.8) {
         if (result.confidence > results.confidence) {
+          if (debug) {
+            console.log(`    → Selected as best match (confidence ${result.confidence} > ${results.confidence})`);
+          }
           results.detected = detector.name;
           results.confidence = result.confidence;
           results.metadata = result.metadata;
+        } else if (debug) {
+          console.log(`    → Skipped (confidence ${result.confidence} <= ${results.confidence})`);
         }
       }
     } catch (error) {
@@ -68,6 +86,10 @@ function detectProjectType(projectPath = process.cwd()) {
     }
   }
 
+  if (debug) {
+    console.log(`\n[DEBUG] Registry: Final result: ${results.detected} (confidence: ${results.confidence})`);
+  }
+
   return results;
 }
 

package/src/generators/manifest-generator.js

@@ -0,0 +1,154 @@
+/**
+ * Manifest Generator
+ * Generates and manages the .l4yercak3.json project manifest file
+ *
+ * The manifest captures the project's structure (framework, models, routes)
+ * and is used by the platform to understand and integrate with the app.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const MANIFEST_FILENAME = '.l4yercak3.json';
+const MANIFEST_VERSION = '1.0.0';
+
+class ManifestGenerator {
+  /**
+   * Generate or update the .l4yercak3.json manifest
+   * @param {object} options
+   * @param {string} options.projectPath - Project root directory
+   * @param {object} options.detection - Detection results from ProjectDetector
+   * @param {Array} options.models - Detected models from model-detector
+   * @param {Array} options.routes - Detected routes from page-detector (with methods)
+   * @param {Array} options.mappings - Suggested mappings from mapping-suggestor
+   * @returns {string} Path to the generated manifest file
+   */
+  generate(options) {
+    const { projectPath, detection, models, routes, mappings } = options;
+    const manifestPath = path.join(projectPath, MANIFEST_FILENAME);
+
+    // Read existing manifest to preserve user overrides
+    const existing = this.loadManifest(projectPath);
+
+    const manifest = {
+      version: MANIFEST_VERSION,
+      framework: detection?.framework?.type || 'unknown',
+      routerType: detection?.framework?.metadata?.routerType || null,
+      typescript: detection?.framework?.metadata?.hasTypeScript || false,
+      database: detection?.database?.primary?.type || null,
+      detectedModels: (models || []).map(m => ({
+        name: m.name,
+        source: m.source,
+        fields: m.fields || [],
+      })),
+      detectedRoutes: (routes || [])
+        .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,
+      })),
+      lastSyncedAt: new Date().toISOString(),
+    };
+
+    // Preserve user overrides from existing manifest
+    if (existing && existing.userOverrides) {
+      manifest.userOverrides = existing.userOverrides;
+    }
+
+    // Preserve confirmed mappings from existing manifest
+    if (existing && existing.confirmedMappings) {
+      manifest.confirmedMappings = existing.confirmedMappings;
+    }
+
+    fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    return manifestPath;
+  }
+
+  /**
+   * Load an existing manifest from a project
+   * @param {string} projectPath - Project root directory
+   * @returns {object|null} Parsed manifest or null if not found
+   */
+  loadManifest(projectPath) {
+    const manifestPath = path.join(projectPath, MANIFEST_FILENAME);
+    try {
+      if (!fs.existsSync(manifestPath)) {
+        return null;
+      }
+      const content = fs.readFileSync(manifestPath, 'utf8');
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Check if a manifest exists in the project
+   * @param {string} projectPath
+   * @returns {boolean}
+   */
+  hasManifest(projectPath) {
+    return fs.existsSync(path.join(projectPath, MANIFEST_FILENAME));
+  }
+
+  /**
+   * Compute a diff between old and new manifest data
+   * @param {object} oldManifest - Previous manifest
+   * @param {object} newManifest - New manifest data
+   * @returns {object} Diff summary
+   */
+  diff(oldManifest, newManifest) {
+    const result = {
+      modelsAdded: [],
+      modelsRemoved: [],
+      routesAdded: [],
+      routesRemoved: [],
+      mappingsChanged: [],
+      hasChanges: false,
+    };
+
+    if (!oldManifest) {
+      result.modelsAdded = newManifest.detectedModels || [];
+      result.routesAdded = newManifest.detectedRoutes || [];
+      result.hasChanges = result.modelsAdded.length > 0 || result.routesAdded.length > 0;
+      return result;
+    }
+
+    // Compare models
+    const oldModelNames = new Set((oldManifest.detectedModels || []).map(m => m.name));
+    const newModelNames = new Set((newManifest.detectedModels || []).map(m => m.name));
+
+    for (const m of (newManifest.detectedModels || [])) {
+      if (!oldModelNames.has(m.name)) result.modelsAdded.push(m);
+    }
+    for (const m of (oldManifest.detectedModels || [])) {
+      if (!newModelNames.has(m.name)) result.modelsRemoved.push(m);
+    }
+
+    // Compare routes
+    const oldRoutePaths = new Set((oldManifest.detectedRoutes || []).map(r => r.path));
+    const newRoutePaths = new Set((newManifest.detectedRoutes || []).map(r => r.path));
+
+    for (const r of (newManifest.detectedRoutes || [])) {
+      if (!oldRoutePaths.has(r.path)) result.routesAdded.push(r);
+    }
+    for (const r of (oldManifest.detectedRoutes || [])) {
+      if (!newRoutePaths.has(r.path)) result.routesRemoved.push(r);
+    }
+
+    result.hasChanges =
+      result.modelsAdded.length > 0 ||
+      result.modelsRemoved.length > 0 ||
+      result.routesAdded.length > 0 ||
+      result.routesRemoved.length > 0;
+
+    return result;
+  }
+}
+
+module.exports = new ManifestGenerator();