@l4yercak3/cli 1.2.0 → 1.2.2

package/docs/ADDING_FRAMEWORK_DETECTORS.md

@@ -0,0 +1,391 @@
+# Adding New Framework Detectors
+
+This guide explains how to add support for new frameworks/platforms to the L4YERCAK3 CLI.
+
+## Overview
+
+The CLI uses a detector system to identify what type of project it's running in. Each detector:
+1. Checks if the project matches its framework
+2. Returns metadata about the project (version, router type, TypeScript, etc.)
+3. Specifies which features and generators are supported
+
+## Architecture
+
+```
+src/detectors/
+├── base-detector.js     # Base class all detectors extend
+├── registry.js          # Central registry that runs all detectors
+├── index.js             # Main entry point (orchestrates detection)
+├── nextjs-detector.js   # Next.js detector
+├── expo-detector.js     # Expo/React Native detector
+└── [your-detector].js   # Your new detector
+```
+
+## Step 1: Create the Detector File
+
+Create a new file in `src/detectors/` named `{framework}-detector.js`.
+
+### Template
+
+```javascript
+/**
+ * {Framework} Project Detector
+ * Detects {Framework} projects and their configuration
+ */
+
+const fs = require('fs');
+const path = require('path');
+const BaseDetector = require('./base-detector');
+
+class {Framework}Detector extends BaseDetector {
+  /**
+   * Unique identifier for this framework
+   * Used in registration data and throughout the CLI
+   */
+  get name() {
+    return '{framework}'; // lowercase, e.g., 'remix', 'astro', 'sveltekit'
+  }
+
+  /**
+   * Detection priority (0-100)
+   *
+   * Guidelines:
+   * - 100: Meta-frameworks (Next.js, Nuxt, SvelteKit)
+   * - 95: Platform-specific (Expo, Tauri)
+   * - 75: Framework + bundler (Vite + React)
+   * - 50: Pure frameworks (React, Vue)
+   * - 25: Generic projects
+   */
+  get priority() {
+    return 90; // Adjust based on specificity
+  }
+
+  /**
+   * Detect if this is a {Framework} project
+   *
+   * @param {string} projectPath - Directory to check
+   * @returns {object} Detection result
+   */
+  detect(projectPath = process.cwd()) {
+    // 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 framework-specific dependency
+      if (!dependencies['{framework-package}']) {
+        return { detected: false, confidence: 0, metadata: {} };
+      }
+
+      // Gather metadata
+      const metadata = {
+        version: dependencies['{framework-package}'],
+        hasTypeScript: !!dependencies.typescript ||
+                       fs.existsSync(path.join(projectPath, 'tsconfig.json')),
+        // Add framework-specific metadata:
+        routerType: this.detectRouterType(dependencies),
+        // config, plugins, etc.
+      };
+
+      return {
+        detected: true,
+        confidence: 0.95, // Adjust based on detection certainty
+        metadata,
+      };
+    } catch (error) {
+      return { detected: false, confidence: 0, metadata: {} };
+    }
+  }
+
+  /**
+   * Detect router type for this framework
+   * IMPORTANT: Always return a string, never null/undefined
+   */
+  detectRouterType(dependencies) {
+    // Example for a framework with multiple router options
+    if (dependencies['{file-router-package}']) {
+      return 'file-based';
+    } else if (dependencies['{other-router}']) {
+      return 'manual';
+    }
+    return 'default'; // Always have a fallback!
+  }
+
+  /**
+   * Features supported by this framework
+   */
+  getSupportedFeatures() {
+    return {
+      oauth: true,      // true = full support, 'manual' = guide only, false = none
+      stripe: true,     // Payment integration
+      crm: true,        // CRM API access
+      projects: true,   // Projects feature
+      invoices: true,   // Invoices feature
+    };
+  }
+
+  /**
+   * Available generators for this framework
+   */
+  getAvailableGenerators() {
+    return [
+      'api-client',    // Always include - generates API client
+      'env',           // Always include - generates .env.local
+      'oauth-guide',   // Include if oauth is supported
+      // Framework-specific generators:
+      // '{framework}-auth',
+    ];
+  }
+}
+
+module.exports = new {Framework}Detector();
+```
+
+## Step 2: Register the Detector
+
+Add your detector to `src/detectors/registry.js`:
+
+```javascript
+const nextJsDetector = require('./nextjs-detector');
+const expoDetector = require('./expo-detector');
+const yourDetector = require('./{framework}-detector'); // Add this
+
+const detectors = [
+  nextJsDetector,
+  expoDetector,
+  yourDetector, // Add this
+];
+```
+
+## Step 3: Update File Generators (if needed)
+
+If your framework needs special file generation, update `src/generators/index.js`:
+
+```javascript
+// Check for your framework
+if (frameworkType === '{framework}') {
+  // Generate framework-specific files
+}
+```
+
+And update `src/generators/api-client-generator.js` for proper file paths:
+
+```javascript
+isMobileFramework(frameworkType) {
+  return ['expo', 'react-native', '{framework}'].includes(frameworkType);
+}
+```
+
+## Step 4: Update Spread Command (if needed)
+
+If your framework needs special handling in the setup flow, update `src/commands/spread.js`:
+
+```javascript
+// Framework-specific detection display
+if (detection.framework.type === '{framework}') {
+  console.log(chalk.gray(`     Router: ${meta.routerType}`));
+}
+
+// Framework-specific next steps
+if (frameworkType === '{framework}') {
+  console.log(chalk.gray('     3. Install {framework}-specific package'));
+}
+```
+
+## Step 5: Write Tests
+
+Create `tests/{framework}-detector.test.js`:
+
+```javascript
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+const detector = require('../src/detectors/{framework}-detector');
+
+describe('{Framework}Detector', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('detects {framework} project', () => {
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue(JSON.stringify({
+      dependencies: {
+        '{framework-package}': '^1.0.0',
+      },
+    }));
+
+    const result = detector.detect('/test/project');
+
+    expect(result.detected).toBe(true);
+    expect(result.confidence).toBeGreaterThan(0.8);
+  });
+
+  it('returns correct metadata', () => {
+    fs.existsSync.mockImplementation((p) => {
+      if (p.includes('tsconfig.json')) return true;
+      if (p.includes('package.json')) return true;
+      return false;
+    });
+    fs.readFileSync.mockReturnValue(JSON.stringify({
+      dependencies: {
+        '{framework-package}': '^1.0.0',
+        'typescript': '^5.0.0',
+      },
+    }));
+
+    const result = detector.detect('/test/project');
+
+    expect(result.metadata.hasTypeScript).toBe(true);
+    expect(result.metadata.routerType).toBeDefined();
+  });
+
+  it('does not detect non-{framework} project', () => {
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue(JSON.stringify({
+      dependencies: {
+        'some-other-framework': '^1.0.0',
+      },
+    }));
+
+    const result = detector.detect('/test/project');
+
+    expect(result.detected).toBe(false);
+  });
+});
+```
+
+## Important Rules
+
+### 1. Always Return a Router Type
+
+The backend expects `routerType` to be a string if present. Never return `null` or `undefined`:
+
+```javascript
+// ❌ Bad
+routerType: dependencies['some-router'] ? 'router' : null,
+
+// ✅ Good
+routerType: dependencies['some-router'] ? 'specific-router' : 'default',
+```
+
+### 2. Priority Order Matters
+
+Higher priority detectors run first. If a project could match multiple detectors (e.g., Next.js is also React), the more specific one should have higher priority.
+
+### 3. Confidence Levels
+
+- `0.95+`: Very certain (found framework + config file)
+- `0.85-0.94`: Certain (found framework package)
+- `0.70-0.84`: Likely (found related packages)
+- `< 0.70`: Uncertain
+
+### 4. Metadata Requirements
+
+These fields should always be present in metadata if applicable:
+- `version`: Framework version from package.json
+- `hasTypeScript`: Boolean
+- `routerType`: String (never null!)
+- `config`: Config file name if detected
+
+## Example: Adding Remix Support
+
+```javascript
+// src/detectors/remix-detector.js
+
+const fs = require('fs');
+const path = require('path');
+const BaseDetector = require('./base-detector');
+
+class RemixDetector extends BaseDetector {
+  get name() {
+    return 'remix';
+  }
+
+  get priority() {
+    return 100; // Meta-framework, high priority
+  }
+
+  detect(projectPath = process.cwd()) {
+    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 Remix
+      if (!dependencies['@remix-run/react']) {
+        return { detected: false, confidence: 0, metadata: {} };
+      }
+
+      // Detect adapter
+      let adapter = 'node'; // default
+      if (dependencies['@remix-run/vercel']) adapter = 'vercel';
+      else if (dependencies['@remix-run/cloudflare']) adapter = 'cloudflare';
+      else if (dependencies['@remix-run/deno']) adapter = 'deno';
+
+      return {
+        detected: true,
+        confidence: 0.95,
+        metadata: {
+          version: dependencies['@remix-run/react'],
+          hasTypeScript: !!dependencies.typescript ||
+                         fs.existsSync(path.join(projectPath, 'tsconfig.json')),
+          routerType: 'file-based', // Remix always uses file-based routing
+          adapter,
+        },
+      };
+    } catch {
+      return { detected: false, confidence: 0, metadata: {} };
+    }
+  }
+
+  getSupportedFeatures() {
+    return {
+      oauth: true,
+      stripe: true,
+      crm: true,
+      projects: true,
+      invoices: true,
+    };
+  }
+
+  getAvailableGenerators() {
+    return ['api-client', 'env', 'oauth-guide'];
+  }
+}
+
+module.exports = new RemixDetector();
+```
+
+## Checklist
+
+Before submitting a new detector:
+
+- [ ] Detector extends `BaseDetector`
+- [ ] `name` getter returns lowercase string
+- [ ] `priority` is set appropriately (0-100)
+- [ ] `detect()` returns `{ detected, confidence, metadata }`
+- [ ] `routerType` in metadata is never null/undefined
+- [ ] `getSupportedFeatures()` returns feature matrix
+- [ ] `getAvailableGenerators()` returns generator list
+- [ ] Detector is registered in `registry.js`
+- [ ] Tests are written and passing
+- [ ] File generators updated if needed
+- [ ] Spread command updated if needed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@l4yercak3/cli",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Icing on the L4yercak3 - The sweet finishing touch for your Layer Cake integration",
   "main": "src/index.js",
   "bin": {

package/src/commands/spread.js

@@ -477,19 +477,26 @@ async function handleSpread() {
         }
       } else {
         // Register new application
+        // Build source object, only including routerType if it has a value
+        const sourceData = {
+          type: 'cli',
+          projectPathHash,
+          cliVersion: pkg.version,
+          framework: detection.framework.type || 'unknown',
+          frameworkVersion: detection.framework.metadata?.version,
+          hasTypeScript: detection.framework.metadata?.hasTypeScript || false,
+        };
+
+        // Only add routerType if it exists (Next.js has 'app'/'pages', Expo has 'expo-router'/'react-navigation')
+        if (detection.framework.metadata?.routerType) {
+          sourceData.routerType = detection.framework.metadata.routerType;
+        }
+
         const registrationData = {
           organizationId,
           name: detection.github.repo || organizationName || 'My Application',
           description: `Connected via CLI from ${detection.framework.type || 'unknown'} project`,
-          source: {
-            type: 'cli',
-            projectPathHash,
-            cliVersion: pkg.version,
-            framework: detection.framework.type || 'unknown',
-            frameworkVersion: detection.framework.metadata?.version,
-            hasTypeScript: detection.framework.metadata?.hasTypeScript || false,
-            routerType: detection.framework.metadata?.routerType,
-          },
+          source: sourceData,
           connection: {
             features,
             hasFrontendDatabase: !!detection.framework.metadata?.hasPrisma,
@@ -550,9 +557,17 @@ async function handleSpread() {
       console.log(chalk.yellow('  📋 Next steps:\n'));
       console.log(chalk.gray('     1. Follow the OAuth setup guide (OAUTH_SETUP_GUIDE.md)'));
       console.log(chalk.gray('     2. Add OAuth credentials to .env.local'));
-      console.log(chalk.gray('     3. Install NextAuth.js: npm install next-auth'));
-      if (oauthProviders.includes('microsoft')) {
-        console.log(chalk.gray('     4. Install Azure AD provider: npm install next-auth/providers/azure-ad'));
+
+      // Framework-specific OAuth instructions
+      const frameworkType = detection.framework.type;
+      if (frameworkType === 'expo' || frameworkType === 'react-native') {
+        console.log(chalk.gray('     3. Install expo-auth-session: npx expo install expo-auth-session expo-crypto'));
+        console.log(chalk.gray('     4. Configure app.json with your OAuth scheme'));
+      } else {
+        console.log(chalk.gray('     3. Install NextAuth.js: npm install next-auth'));
+        if (oauthProviders.includes('microsoft')) {
+          console.log(chalk.gray('     4. Install Azure AD provider: npm install next-auth/providers/azure-ad'));
+        }
       }
       console.log('');
     }

package/src/detectors/expo-detector.js

@@ -0,0 +1,166 @@
+/**
+ * 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; // High priority - specific framework
+  }
+
+  /**
+   * 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.7; // Base confidence for React Native
+      if (results.isExpo) {
+        confidence = 0.9; // Higher for Expo
+        if (results.config) {
+          confidence = 0.95; // Even higher with config file
+        }
+      }
+
+      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/registry.js

@@ -6,6 +6,7 @@
  */
 
 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');
@@ -16,6 +17,7 @@ const nextJsDetector = require('./nextjs-detector');
  */
 const detectors = [
   nextJsDetector,
+  expoDetector,
   // Future: reactDetector, vueDetector, etc.
 ];
 

package/src/generators/api-client-generator.js

@@ -8,6 +8,13 @@ const path = require('path');
 const { checkFileOverwrite, writeFileWithBackup, ensureDir } = require('../utils/file-utils');
 
 class ApiClientGenerator {
+  /**
+   * Check if framework is a mobile platform
+   */
+  isMobileFramework(frameworkType) {
+    return ['expo', 'react-native'].includes(frameworkType);
+  }
+
   /**
    * Generate API client file
    * @param {Object} options - Generation options
@@ -20,18 +27,26 @@ class ApiClientGenerator {
       backendUrl,
       organizationId,
       isTypeScript,
+      frameworkType,
     } = options;
 
-    // Determine output path based on project structure
-    const libDir = fs.existsSync(path.join(projectPath, 'src'))
-      ? path.join(projectPath, 'src', 'lib')
-      : path.join(projectPath, 'lib');
+    // Determine output path based on framework and project structure
+    let outputDir;
+    if (this.isMobileFramework(frameworkType)) {
+      // Expo/React Native: use src/api or src/services
+      outputDir = path.join(projectPath, 'src', 'api');
+    } else {
+      // Next.js/Web: use lib or src/lib
+      outputDir = fs.existsSync(path.join(projectPath, 'src'))
+        ? path.join(projectPath, 'src', 'lib')
+        : path.join(projectPath, 'lib');
+    }
 
-    // Ensure lib directory exists
-    ensureDir(libDir);
+    // Ensure output directory exists
+    ensureDir(outputDir);
 
     const extension = isTypeScript ? 'ts' : 'js';
-    const outputPath = path.join(libDir, `api-client.${extension}`);
+    const outputPath = path.join(outputDir, `api-client.${extension}`);
 
     // Check if file exists and get action
     const action = await checkFileOverwrite(outputPath);

package/src/generators/index.js

@@ -1,6 +1,10 @@
 /**
  * File Generators
  * Main entry point for all file generation
+ *
+ * Supports multiple frameworks:
+ * - nextjs: Next.js (App Router and Pages Router)
+ * - expo: Expo/React Native
  */
 
 const apiClientGenerator = require('./api-client-generator');
@@ -10,6 +14,20 @@ const oauthGuideGenerator = require('./oauth-guide-generator');
 const gitignoreGenerator = require('./gitignore-generator');
 
 class FileGenerator {
+  /**
+   * Check if framework is a mobile platform
+   */
+  isMobileFramework(frameworkType) {
+    return ['expo', 'react-native'].includes(frameworkType);
+  }
+
+  /**
+   * Check if framework is Next.js
+   */
+  isNextJs(frameworkType) {
+    return frameworkType === 'nextjs';
+  }
+
   /**
    * Generate all files based on configuration
    */
@@ -22,6 +40,10 @@ class FileGenerator {
       gitignore: null,
     };
 
+    const frameworkType = options.frameworkType || 'unknown';
+    const isMobile = this.isMobileFramework(frameworkType);
+    const isNextJs = this.isNextJs(frameworkType);
+
     // Generate API client (async - checks for file overwrites)
     if (options.features && options.features.length > 0) {
       results.apiClient = await apiClientGenerator.generate(options);
@@ -30,14 +52,22 @@ class FileGenerator {
     // Generate environment file
     results.envFile = envGenerator.generate(options);
 
-    // Generate NextAuth.js config if OAuth is enabled (async - checks for file overwrites)
+    // Generate NextAuth.js config if OAuth is enabled (Next.js only)
     if (options.features && options.features.includes('oauth') && options.oauthProviders) {
-      results.nextauth = await nextauthGenerator.generate(options);
+      if (isNextJs) {
+        results.nextauth = await nextauthGenerator.generate(options);
+      }
+      // For mobile, OAuth is handled differently (expo-auth-session, etc.)
     }
 
     // Generate OAuth guide if OAuth is enabled
     if (options.features && options.features.includes('oauth') && options.oauthProviders) {
-      results.oauthGuide = oauthGuideGenerator.generate(options);
+      // Pass framework info so guide can be customized
+      results.oauthGuide = oauthGuideGenerator.generate({
+        ...options,
+        isMobile,
+        isNextJs,
+      });
     }
 
     // Update .gitignore

package/tests/expo-detector.test.js

@@ -0,0 +1,264 @@
+/**
+ * Tests for Expo/React Native Project Detector
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+const detector = require('../src/detectors/expo-detector');
+
+describe('ExpoDetector', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('basic detection', () => {
+    it('detects Expo project', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          expo: '^51.0.0',
+          'react-native': '0.74.0',
+        },
+      }));
+
+      const result = detector.detect('/test/project');
+
+      expect(result.detected).toBe(true);
+      expect(result.confidence).toBeGreaterThan(0.8);
+      expect(result.metadata.isExpo).toBe(true);
+      expect(result.metadata.expoVersion).toBe('^51.0.0');
+    });
+
+    it('detects React Native project without Expo (below confidence threshold)', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          'react-native': '0.74.0',
+        },
+      }));
+
+      const result = detector.detect('/test/project');
+
+      // Pure React Native has lower confidence (0.7)
+      // which is below the 0.8 threshold, so it won't be the "detected" match
+      // but the detector still returns useful data
+      expect(result.detected).toBe(true);
+      expect(result.confidence).toBe(0.7);
+    });
+
+    it('does not detect non-Expo/React Native project', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          next: '^14.0.0',
+          react: '^18.0.0',
+        },
+      }));
+
+      const result = detector.detect('/test/project');
+
+      expect(result.detected).toBe(false);
+    });
+
+    it('does not detect when no package.json', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = detector.detect('/test/project');
+
+      expect(result.detected).toBe(false);
+      expect(result.confidence).toBe(0);
+    });
+  });
+
+  describe('routerType detection', () => {
+    it('detects expo-router', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          expo: '^51.0.0',
+          'expo-router': '^3.5.0',
+          'react-native': '0.74.0',
+        },
+      }));
+
+      const result = detector.detect('/test/project');
+
+      expect(result.detected).toBe(true);
+      expect(result.metadata.routerType).toBe('expo-router');
+    });
+
+    it('detects react-navigation', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          expo: '^51.0.0',
+          '@react-navigation/native': '^6.0.0',
+          'react-native': '0.74.0',
+        },
+      }));
+
+      const result = detector.detect('/test/project');
+
+      expect(result.detected).toBe(true);
+      expect(result.metadata.routerType).toBe('react-navigation');
+    });
+
+    it('defaults to native when no router package is present', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          expo: '^51.0.0',
+          'react-native': '0.74.0',
+        },
+      }));
+
+      const result = detector.detect('/test/project');
+
+      expect(result.detected).toBe(true);
+      expect(result.metadata.routerType).toBe('native');
+    });
+
+    it('NEVER returns null for routerType when project is detected', () => {
+      // This is the critical test - routerType must never be null
+      // when the project is successfully detected
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          expo: '^51.0.0',
+          'react-native': '0.74.0',
+          // No router packages at all
+        },
+      }));
+
+      const result = detector.detect('/test/project');
+
+      expect(result.detected).toBe(true);
+      // This must NEVER be null - backend requires string
+      expect(result.metadata.routerType).not.toBeNull();
+      expect(result.metadata.routerType).not.toBeUndefined();
+      expect(typeof result.metadata.routerType).toBe('string');
+    });
+  });
+
+  describe('TypeScript detection', () => {
+    it('detects TypeScript via dependency', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          expo: '^51.0.0',
+          'react-native': '0.74.0',
+        },
+        devDependencies: {
+          typescript: '^5.0.0',
+        },
+      }));
+
+      const result = detector.detect('/test/project');
+
+      expect(result.metadata.hasTypeScript).toBe(true);
+    });
+
+    it('detects TypeScript via tsconfig.json', () => {
+      fs.existsSync.mockImplementation((p) => {
+        if (p.includes('tsconfig.json')) return true;
+        if (p.includes('package.json')) return true;
+        return false;
+      });
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          expo: '^51.0.0',
+          'react-native': '0.74.0',
+        },
+      }));
+
+      const result = detector.detect('/test/project');
+
+      expect(result.metadata.hasTypeScript).toBe(true);
+    });
+  });
+
+  describe('app config detection', () => {
+    it('detects app.json config', () => {
+      fs.existsSync.mockImplementation((p) => {
+        if (p.includes('app.json')) return true;
+        if (p.includes('package.json')) return true;
+        return false;
+      });
+      fs.readFileSync.mockImplementation((p) => {
+        if (p.includes('app.json')) {
+          return JSON.stringify({
+            expo: {
+              sdkVersion: '51.0.0',
+            },
+          });
+        }
+        return JSON.stringify({
+          dependencies: {
+            expo: '^51.0.0',
+            'react-native': '0.74.0',
+          },
+        });
+      });
+
+      const result = detector.detect('/test/project');
+
+      expect(result.metadata.config).toBe('app.json');
+      expect(result.metadata.sdkVersion).toBe('51.0.0');
+      expect(result.confidence).toBe(0.95);
+    });
+
+    it('detects app.config.js config', () => {
+      fs.existsSync.mockImplementation((p) => {
+        if (p.includes('app.config.js')) return true;
+        if (p.includes('package.json')) return true;
+        return false;
+      });
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          expo: '^51.0.0',
+          'react-native': '0.74.0',
+        },
+      }));
+
+      const result = detector.detect('/test/project');
+
+      expect(result.metadata.config).toBe('app.config.js');
+    });
+  });
+
+  describe('features and generators', () => {
+    it('returns supported features', () => {
+      const features = detector.getSupportedFeatures();
+
+      expect(features.oauth).toBe(true);
+      expect(features.stripe).toBe(true);
+      expect(features.crm).toBe(true);
+      expect(features.projects).toBe(true);
+      expect(features.invoices).toBe(true);
+    });
+
+    it('returns available generators', () => {
+      const generators = detector.getAvailableGenerators();
+
+      expect(generators).toContain('api-client');
+      expect(generators).toContain('env');
+      expect(generators).toContain('oauth-guide');
+      // Should NOT include Next.js specific generators
+      expect(generators).not.toContain('nextauth');
+    });
+  });
+
+  describe('detector properties', () => {
+    it('has correct name', () => {
+      expect(detector.name).toBe('expo');
+    });
+
+    it('has high priority', () => {
+      expect(detector.priority).toBe(95);
+      // Should be higher than generic React but lower than Expo with config
+    });
+  });
+});

package/tests/generators-index.test.js

@@ -98,7 +98,7 @@ describe('FileGenerator', () => {
       expect(result.envFile).toContain('.env.local');
     });
 
-    it('generates NextAuth config when oauth feature enabled', async () => {
+    it('generates NextAuth config when oauth feature enabled (Next.js)', async () => {
       const options = {
         projectPath: mockProjectPath,
         apiKey: 'test-key',
@@ -108,6 +108,7 @@ describe('FileGenerator', () => {
         oauthProviders: ['google'],
         isTypeScript: false,
         routerType: 'app',
+        frameworkType: 'nextjs', // NextAuth is Next.js only
       };
 
       const result = await FileGenerator.generate(options);
@@ -115,6 +116,23 @@ describe('FileGenerator', () => {
       expect(result.nextauth).not.toBeNull();
     });
 
+    it('does not generate NextAuth for Expo/mobile apps', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['oauth'],
+        oauthProviders: ['google'],
+        isTypeScript: true,
+        frameworkType: 'expo',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.nextauth).toBeNull();
+    });
+
     it('does not generate NextAuth when oauth not in features', async () => {
       const options = {
         projectPath: mockProjectPath,
@@ -198,7 +216,7 @@ describe('FileGenerator', () => {
       expect(result).toHaveProperty('gitignore');
     });
 
-    it('generates all files when all features enabled', async () => {
+    it('generates all files when all features enabled (Next.js)', async () => {
       const options = {
         projectPath: mockProjectPath,
         apiKey: 'test-key',
@@ -210,6 +228,7 @@ describe('FileGenerator', () => {
         routerType: 'app',
         productionDomain: 'example.com',
         appName: 'Full App',
+        frameworkType: 'nextjs',
       };
 
       const result = await FileGenerator.generate(options);