@l4yercak3/cli 1.2.1 → 1.2.3

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.1",
+  "version": "1.2.3",
   "description": "Icing on the L4yercak3 - The sweet finishing touch for your Layer Cake integration",
   "main": "src/index.js",
   "bin": {

package/src/commands/spread.js

@@ -242,6 +242,7 @@ async function handleSpread() {
             value: key.id,
           }));
           keyChoices.push({ name: '➕ Generate a new API key', value: '__generate__' });
+          keyChoices.push({ name: '⏭️  Skip - I already have my key configured', value: '__skip__' });
 
           const { keyChoice } = await inquirer.prompt([
             {
@@ -254,6 +255,9 @@ async function handleSpread() {
 
           if (keyChoice === '__generate__') {
             apiKey = await generateNewApiKey(organizationId);
+          } else if (keyChoice === '__skip__') {
+            apiKey = null; // Will skip writing API key to .env.local
+            console.log(chalk.green(`  ✅ Skipping API key setup - using existing configuration\n`));
           } else {
             // User selected existing key - we only have the preview, not the full key
             // They need to use the key they have stored or get it from dashboard
@@ -477,19 +481,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 +561,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

@@ -75,10 +75,13 @@ class ExpoDetector extends BaseDetector {
       }
 
       // 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)

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);
@@ -56,11 +71,15 @@ class ApiClientGenerator {
    */
   generateCode({ apiKey, backendUrl, organizationId, isTypeScript }) {
     const returnType = isTypeScript ? ': Promise<any>' : '';
+    // If apiKey is null (user skipped), use environment variable reference
+    const apiKeyDefault = apiKey
+      ? `'${apiKey}'`
+      : `process.env.L4YERCAK3_API_KEY || ''`;
 
     return `/**
  * L4YERCAK3 API Client
  * Auto-generated by @l4yercak3/cli
- * 
+ *
  * This client handles authenticated requests to the L4YERCAK3 backend API.
  * Organization ID: ${organizationId}
  */
@@ -68,7 +87,7 @@ class ApiClientGenerator {
 // Using native fetch (available in Next.js 13+)
 
 class L4YERCAK3Client {
-  constructor(apiKey${isTypeScript ? ': string' : ''} = '${apiKey}', baseUrl${isTypeScript ? ': string' : ''} = '${backendUrl}') {
+  constructor(apiKey${isTypeScript ? ': string' : ''} = ${apiKeyDefault}, baseUrl${isTypeScript ? ': string' : ''} = '${backendUrl}') {
     this.apiKey = apiKey;
     this.baseUrl = baseUrl;
     this.organizationId = '${organizationId}';

package/src/generators/env-generator.js

@@ -27,7 +27,8 @@ class EnvGenerator {
     const envVars = {
       ...existingEnv,
       // Core API configuration
-      L4YERCAK3_API_KEY: apiKey,
+      // If apiKey is null (user skipped), preserve existing value
+      L4YERCAK3_API_KEY: apiKey || existingEnv.L4YERCAK3_API_KEY || 'your_api_key_here',
       L4YERCAK3_BACKEND_URL: backendUrl,
       L4YERCAK3_ORGANIZATION_ID: organizationId,
       NEXT_PUBLIC_L4YERCAK3_BACKEND_URL: backendUrl,

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);