embedia/src/frameworks/frameworkAdapter.js

Zero-configuration AI chatbot integration CLI - direct file copy with embedded API keys

const fs = require('fs-extra');
const path = require('path');

// Import individual adapters
const NextJSAdapter = require('./adapters/NextJSAdapter');
const GatsbyAdapter = require('./adapters/GatsbyAdapter');
const RemixAdapter = require('./adapters/RemixAdapter');
const ViteAdapter = require('./adapters/ViteAdapter');
const CRAAdapter = require('./adapters/CRAAdapter');
const UniversalAdapter = require('./adapters/UniversalAdapter');
const WebComponentAdapter = require('./adapters/WebComponentAdapter');

class FrameworkAdapter {
  constructor() {
    this.adapters = {
      next: NextJSAdapter,
      gatsby: GatsbyAdapter,
      remix: RemixAdapter,
      vite: ViteAdapter,
      'create-react-app': CRAAdapter,
      react: UniversalAdapter,
      webcomponent: WebComponentAdapter,
      unknown: UniversalAdapter
    };
  }
  
  async getAdapter(projectPath, framework, projectAnalysis) {
    const AdapterClass = this.adapters[framework.name];
    
    if (!AdapterClass) {
      console.log(`Framework ${framework.name} not directly supported, using universal adapter`);
      return new UniversalAdapter(projectPath, framework, projectAnalysis);
    }
    
    return new AdapterClass(projectPath, framework, projectAnalysis);
  }
  
  async detectFramework(projectPath) {
    const packageJson = await this.readPackageJson(projectPath);
    
    // Detection logic for each framework
    if (packageJson.dependencies?.next || packageJson.devDependencies?.next) {
      const version = packageJson.dependencies?.next || packageJson.devDependencies?.next;
      return { 
        name: 'next', 
        version: version.replace(/[\^~]/, ''),
        majorVersion: parseInt(version.match(/\d+/)?.[0] || '0')
      };
    }
    
    if (packageJson.dependencies?.gatsby) {
      return { 
        name: 'gatsby', 
        version: packageJson.dependencies.gatsby.replace(/[\^~]/, '') 
      };
    }
    
    if (packageJson.dependencies?.['@remix-run/react']) {
      return { 
        name: 'remix', 
        version: packageJson.dependencies['@remix-run/react'].replace(/[\^~]/, '') 
      };
    }
    
    if (packageJson.dependencies?.nuxt) {
      return { 
        name: 'nuxt', 
        version: packageJson.dependencies.nuxt.replace(/[\^~]/, '') 
      };
    }
    
    if (packageJson.dependencies?.vite && packageJson.dependencies?.react) {
      return { 
        name: 'vite', 
        version: packageJson.dependencies.vite.replace(/[\^~]/, '') 
      };
    }
    
    if (packageJson.dependencies?.['react-scripts']) {
      return { 
        name: 'create-react-app', 
        version: packageJson.dependencies['react-scripts'].replace(/[\^~]/, '') 
      };
    }
    
    // Check for plain React
    if (packageJson.dependencies?.react) {
      return { 
        name: 'react', 
        version: packageJson.dependencies.react.replace(/[\^~]/, '') 
      };
    }
    
    return { name: 'unknown', version: null };
  }
  
  async readPackageJson(projectPath) {
    try {
      const packageJsonPath = path.join(projectPath, 'package.json');
      if (await fs.pathExists(packageJsonPath)) {
        return await fs.readJson(packageJsonPath);
      }
    } catch (error) {
      console.error('Error reading package.json:', error);
    }
    return {};
  }
  
  getSupportedFrameworks() {
    return Object.keys(this.adapters).filter(f => f !== 'unknown');
  }
  
  isFrameworkSupported(frameworkName) {
    return this.adapters.hasOwnProperty(frameworkName);
  }
}

module.exports = FrameworkAdapter;