@l4yercak3/cli 1.3.1 → 2.0.0-alpha.0

package/src/detectors/page-detector.js

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

@@ -1,121 +0,0 @@
-/**
- * Detector Registry
- * 
- * Central registry for all project type detectors.
- * Detectors are automatically sorted by priority (highest first).
- */
-
-const nextJsDetector = require('./nextjs-detector');
-const expoDetector = require('./expo-detector');
-// Future detectors will be added here:
-// const reactDetector = require('./react-detector');
-// const vueDetector = require('./vue-detector');
-
-/**
- * All registered detectors
- * Add new detectors here as they're implemented
- */
-const detectors = [
-  nextJsDetector,
-  expoDetector,
-  // Future: reactDetector, vueDetector, etc.
-];
-
-/**
- * Sort detectors by priority (highest first)
- */
-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
- */
-function detectProjectType(projectPath = process.cwd()) {
-  const results = {
-    detected: null,      // Best match detector
-    confidence: 0,       // Confidence of best match
-    metadata: {},       // Metadata from best match
-    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,
-        ...result,
-      });
-
-      // 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) {
-      console.error(`Error in detector ${detector.name}:`, error);
-      // Continue with other detectors
-    }
-  }
-
-  if (debug) {
-    console.log(`\n[DEBUG] Registry: Final result: ${results.detected} (confidence: ${results.confidence})`);
-  }
-
-  return results;
-}
-
-/**
- * Get detector by name
- * 
- * @param {string} name - Detector name
- * @returns {object|null} Detector instance or null
- */
-function getDetector(name) {
-  return detectors.find(d => d.name === name) || null;
-}
-
-/**
- * Get all registered detectors
- * 
- * @returns {array} Array of detector instances
- */
-function getAllDetectors() {
-  return sortedDetectors;
-}
-
-module.exports = {
-  detectProjectType,
-  getDetector,
-  getAllDetectors,
-  detectors: sortedDetectors, // Expose sorted list
-};
-