humanbehavior-js 0.4.6 → 0.4.8

package/src/wizard/ai/manual-framework-wizard.ts

@@ -0,0 +1,236 @@
+/**
+ * Manual Framework Installation Wizard
+ * 
+ * This wizard allows users to manually specify their framework instead of auto-detection.
+ * Useful when auto-detection fails or users want more control.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { AutoInstallationWizard, FrameworkInfo, CodeModification, InstallationResult } from '../core/install-wizard';
+import { RemoteAIService } from '../services/remote-ai-service';
+
+export interface ManualInstallationResult extends InstallationResult {
+  selectedFramework: string;
+  manualMode: boolean;
+}
+
+export class ManualFrameworkInstallationWizard extends AutoInstallationWizard {
+  private selectedFramework: string;
+
+  constructor(apiKey: string, projectRoot: string = process.cwd(), framework: string) {
+    super(apiKey, projectRoot);
+    this.selectedFramework = framework.toLowerCase();
+    this.framework = this.createFrameworkInfo(this.selectedFramework);
+  }
+
+  /**
+   * Manual installation with user-specified framework
+   */
+  async install(): Promise<ManualInstallationResult> {
+    try {
+      // Step 1: Handle framework selection
+      if (this.selectedFramework === 'auto') {
+        // Use full AI detection for "Other" option
+        this.framework = await this.runFullDetection();
+      } else {
+        // Set framework based on user selection
+        this.framework = this.createFrameworkInfo(this.selectedFramework);
+        if (!this.framework) {
+          this.framework = { name: 'unknown', type: 'vanilla' };
+        }
+        
+        // Step 2: Run full detection logic to find entry points, file names, etc.
+        const detectedFramework = await this.runFullDetection();
+        
+        // Step 3: Merge manual framework with detected details
+        this.framework = {
+          ...detectedFramework,
+          name: this.framework.name,
+          type: this.framework.type
+        };
+      }
+      
+      // Step 4: Install package
+      await this.installPackage();
+      
+      // Step 5: Generate and apply code modifications
+      const modifications = await this.generateModifications();
+      await this.applyModifications(modifications);
+      
+      // Step 6: Generate next steps
+      const nextSteps = this.generateManualNextSteps();
+      
+      return {
+        success: true,
+        framework: this.framework,
+        modifications,
+        errors: [],
+        nextSteps,
+        selectedFramework: this.selectedFramework,
+        manualMode: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        framework: this.framework || { name: 'unknown', type: 'vanilla' },
+        modifications: [],
+        errors: [error instanceof Error ? error.message : 'Unknown error'],
+        nextSteps: [],
+        selectedFramework: this.selectedFramework,
+        manualMode: true
+      };
+    }
+  }
+
+  /**
+   * Run full detection logic to find entry points, file names, bundler, etc.
+   */
+  private async runFullDetection(): Promise<FrameworkInfo> {
+    if (this.selectedFramework === 'auto') {
+      // Use AI service for auto-detection
+      const aiService = new RemoteAIService({
+        apiEndpoint: 'https://ik3zxh4790.execute-api.us-east-1.amazonaws.com/prod'
+      });
+      
+      // Use AI service directly for detection
+      const projectFiles = await this.scanProjectFiles();
+      const codeSamples = await this.extractCodeSamples(projectFiles);
+      const aiAnalysis = await aiService.analyzeCodePatterns(codeSamples);
+      return aiAnalysis.framework;
+    } else {
+      // Use traditional detection for manual frameworks
+      const tempWizard = new AutoInstallationWizard(this.apiKey, this.projectRoot);
+      const detected = await tempWizard.detectFramework();
+      return detected;
+    }
+  }
+
+  /**
+   * Scan project files for analysis
+   */
+  private async scanProjectFiles(): Promise<string[]> {
+    const files: string[] = [];
+    const scanDir = (dir: string, depth: number = 0) => {
+      if (depth > 3) return; // Limit depth
+      
+      try {
+        const items = fs.readdirSync(dir);
+        for (const item of items) {
+          const fullPath = path.join(dir, item);
+          const stat = fs.statSync(fullPath);
+          
+          if (stat.isDirectory() && !item.startsWith('.') && item !== 'node_modules') {
+            scanDir(fullPath, depth + 1);
+          } else if (stat.isFile() && this.isRelevantFile(item)) {
+            files.push(fullPath);
+          }
+        }
+      } catch (error) {
+        // Skip inaccessible directories
+      }
+    };
+    
+    scanDir(this.projectRoot);
+    return files;
+  }
+
+  /**
+   * Check if file is relevant for analysis
+   */
+  private isRelevantFile(filename: string): boolean {
+    const relevantExtensions = [
+      '.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte', '.html',
+      '.json', '.config.js', '.config.ts', '.babelrc', '.eslintrc'
+    ];
+    
+    const relevantNames = [
+      'package.json', 'tsconfig.json', 'vite.config', 'webpack.config',
+      'next.config', 'nuxt.config', 'angular.json', 'svelte.config'
+    ];
+    
+    return relevantExtensions.some(ext => filename.endsWith(ext)) ||
+           relevantNames.some(name => filename.includes(name));
+  }
+
+  /**
+   * Extract code samples for AI analysis
+   */
+  private async extractCodeSamples(files: string[]): Promise<string[]> {
+    const samples: string[] = [];
+    
+    for (const file of files.slice(0, 20)) { // Limit to 20 files
+      try {
+        const content = fs.readFileSync(file, 'utf8');
+        const relativePath = path.relative(this.projectRoot, file);
+        samples.push(`File: ${relativePath}\n${content.substring(0, 1000)}`);
+      } catch (error) {
+        // Skip unreadable files
+      }
+    }
+    
+    return samples;
+  }
+
+  /**
+   * Create framework info based on user selection
+   */
+  private createFrameworkInfo(framework: string): FrameworkInfo {
+    const frameworkMap: Record<string, FrameworkInfo> = {
+      'react': { name: 'react', type: 'react' },
+      'nextjs': { name: 'nextjs', type: 'nextjs' },
+      'next': { name: 'nextjs', type: 'nextjs' },
+      'vue': { name: 'vue', type: 'vue' },
+      'nuxt': { name: 'nuxt', type: 'nuxt' },
+      'nuxtjs': { name: 'nuxt', type: 'nuxt' },
+      'angular': { name: 'angular', type: 'angular' },
+      'svelte': { name: 'svelte', type: 'svelte' },
+      'sveltekit': { name: 'svelte', type: 'svelte' },
+      'remix': { name: 'remix', type: 'remix' },
+      'vanilla': { name: 'vanilla', type: 'vanilla' },
+      'node': { name: 'node', type: 'node' },
+      'auto': { name: 'auto-detected', type: 'auto' }
+    };
+
+    return frameworkMap[framework] || { name: framework, type: 'vanilla' };
+  }
+
+  /**
+   * Override framework detection to use manual selection
+   */
+  public async detectFramework(): Promise<FrameworkInfo> {
+    return this.framework || { name: 'unknown', type: 'vanilla' };
+  }
+
+  /**
+   * Generate next steps with manual mode info
+   */
+  private generateManualNextSteps(): string[] {
+    return [
+      '✅ Manual framework installation completed!',
+      `🎯 Selected framework: ${this.framework?.name || 'unknown'}`,
+      `🔧 Integration strategy: ${this.getIntegrationStrategy()}`,
+      '🚀 Your app is now ready to track user behavior',
+      '📊 View sessions in your HumanBehavior dashboard'
+    ];
+  }
+
+  /**
+   * Get integration strategy based on framework
+   */
+  private getIntegrationStrategy(): string {
+    if (!this.framework?.type) return 'script';
+    
+    switch (this.framework.type) {
+      case 'react':
+      case 'nextjs':
+        return 'provider';
+      case 'vue':
+        return 'plugin';
+      case 'angular':
+        return 'module';
+      default:
+        return 'script';
+    }
+  }
+} 

package/src/wizard/cli/ai-auto-install.ts

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+
+/**
+ * AI-Enhanced HumanBehavior SDK Auto-Installation CLI
+ * 
+ * Usage: npx humanbehavior-js ai-auto-install [api-key]
+ * 
+ * This tool uses AI to intelligently detect frameworks, analyze code patterns,
+ * and generate optimal integration code that's both future-proof and backward-compatible.
+ */
+
+import { AIEnhancedInstallationWizard, AIBrowserInstallationWizard } from '../ai/ai-install-wizard';
+import { ManualFrameworkInstallationWizard } from '../ai/manual-framework-wizard';
+import { AutoInstallationWizard } from '../core/install-wizard';
+import { RemoteAIService } from '../services/remote-ai-service';
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface AICLIOptions {
+  apiKey?: string;
+  projectPath?: string;
+  yes?: boolean;
+  dryRun?: boolean;
+  useAI?: boolean;
+  browser?: boolean;
+  framework?: string;
+  manual?: boolean;
+}
+
+class AIAutoInstallCLI {
+  private rl: readline.Interface;
+  private options: AICLIOptions;
+
+  constructor(options: AICLIOptions) {
+    this.options = options;
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+  }
+
+  async run() {
+    console.log('🤖 AI-Enhanced HumanBehavior SDK Auto-Installation');
+    console.log('================================================\n');
+
+    try {
+      // Get API key
+      const apiKey = await this.getApiKey();
+      if (!apiKey) {
+        console.error('❌ API key is required');
+        process.exit(1);
+      }
+
+      // Get project path
+      const projectPath = this.options.projectPath || process.cwd();
+      
+      // Choose installation mode
+      const installationMode = await this.chooseInstallationMode();
+      
+      // Confirm installation
+      if (!this.options.yes) {
+        const confirmed = await this.confirmInstallation(projectPath, installationMode);
+        if (!confirmed) {
+          console.log('Installation cancelled.');
+          process.exit(0);
+        }
+      }
+
+      // Run installation
+      console.log('🔍 Analyzing your project with AI...');
+      
+      let result;
+      if (this.options.browser) {
+        const wizard = new AIBrowserInstallationWizard(apiKey);
+        result = await wizard.install();
+      } else if (installationMode === 'manual') {
+        // Manual AI-Enhanced framework selection
+        const framework = await this.chooseFramework();
+        const wizard = new ManualFrameworkInstallationWizard(apiKey, projectPath, framework);
+        result = await wizard.install();
+      } else if (installationMode.startsWith('manual:')) {
+        // Manual framework selection with pre-selected framework
+        const framework = installationMode.split(':')[1];
+        const wizard = new ManualFrameworkInstallationWizard(apiKey, projectPath, framework);
+        result = await wizard.install();
+      } else {
+        const wizard = new AutoInstallationWizard(apiKey, projectPath);
+        result = await wizard.install();
+      }
+
+      // Display results
+      this.displayResults(result, installationMode);
+
+    } catch (error) {
+      console.error('❌ Error:', error instanceof Error ? error.message : error);
+      process.exit(1);
+    } finally {
+      this.rl.close();
+    }
+  }
+
+  private async getApiKey(): Promise<string> {
+    if (this.options.apiKey) {
+      return this.options.apiKey;
+    }
+
+    return new Promise((resolve) => {
+      this.rl.question('Enter your HumanBehavior API key: ', (answer) => {
+        resolve(answer.trim());
+      });
+    });
+  }
+
+  private async chooseInstallationMode(): Promise<string> {
+    if (this.options.manual && this.options.framework) {
+      return `manual:${this.options.framework}`;
+    }
+    if (this.options.useAI !== undefined) {
+      return this.options.useAI ? 'ai' : 'traditional';
+    }
+
+    console.log('🤖 Choose installation mode:');
+    console.log('1. Manual AI-Enhanced (recommended) - Choose your framework and use AI for optimization');
+    console.log('2. Traditional - Standard framework detection and installation');
+    console.log('3. Browser - Browser-based AI detection and code generation\n');
+
+          return new Promise((resolve) => {
+        this.rl.question('Select mode (1-3, default: 1): ', (answer) => {
+          const choice = answer.trim() || '1';
+          if (choice === '1') resolve('manual');
+          else if (choice === '2') resolve('traditional');
+          else if (choice === '3') resolve('browser');
+          else resolve('manual');
+        });
+      });
+  }
+
+  private async confirmInstallation(projectPath: string, installationMode: string): Promise<boolean> {
+    console.log(`📁 Project path: ${projectPath}`);
+    console.log(`🤖 Installation mode: ${this.getInstallationModeDisplay(installationMode)}`);
+    console.log('⚠️  This will modify your codebase to integrate HumanBehavior SDK.');
+    console.log('   The following changes will be made:');
+    console.log('   - Install humanbehavior-js package');
+    console.log('   - Analyze code patterns with AI (if enabled)');
+    console.log('   - Modify your main app file');
+    console.log('   - Create environment files');
+    console.log('   - Add AI-optimized SDK initialization code\n');
+
+    return new Promise((resolve) => {
+      this.rl.question('Continue with installation? (y/n): ', (answer) => {
+        resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+      });
+    });
+  }
+
+  private getInstallationModeDisplay(mode: string): string {
+    if (mode === 'manual') return 'Manual AI-Enhanced';
+    if (mode === 'traditional') return 'Traditional';
+    if (mode.startsWith('manual:')) {
+      const framework = mode.split(':')[1];
+      return `Manual AI-Enhanced (${framework})`;
+    }
+    if (mode === 'browser') return 'Browser';
+    return 'Unknown';
+  }
+
+  private async chooseFramework(): Promise<string> {
+    console.log('\n🎯 Choose your framework:');
+    console.log('1. Vanilla JS (HTML)');
+    console.log('2. React');
+    console.log('3. Next.js');
+    console.log('4. Vue');
+    console.log('5. Nuxt');
+    console.log('6. Angular');
+    console.log('7. Svelte');
+    console.log('8. Remix');
+    console.log('9. Node.js');
+    console.log('10. Other (Auto-detect)\n');
+
+    return new Promise((resolve) => {
+      this.rl.question('Select framework (1-10, default: 1): ', (answer) => {
+        const choice = answer.trim() || '1';
+        const frameworks = ['vanilla', 'react', 'nextjs', 'vue', 'nuxt', 'angular', 'svelte', 'remix', 'node', 'auto'];
+        const index = parseInt(choice) - 1;
+        resolve(frameworks[index] || 'vanilla');
+      });
+    });
+  }
+
+  private displayResults(result: any, installationMode: string) {
+    if (result.success) {
+      console.log('\n✅ Installation completed successfully!');
+      
+      if (installationMode === 'ai' && result.aiAnalysis) {
+        console.log(`🎯 AI Analysis Results:`);
+        console.log(`   Framework: ${result.aiAnalysis.framework.name} (confidence: ${Math.round(result.aiAnalysis.confidence * 100)}%)`);
+        console.log(`   Integration Strategy: ${result.aiAnalysis.integrationStrategy}`);
+        console.log(`   Compatibility Mode: ${result.aiAnalysis.compatibilityMode}`);
+        
+        if (result.aiAnalysis.patterns.length > 0) {
+          console.log(`   Detected Patterns: ${result.aiAnalysis.patterns.length} patterns`);
+        }
+        
+        if (result.aiAnalysis.recommendations.length > 0) {
+          console.log(`   AI Recommendations:`);
+          result.aiAnalysis.recommendations.forEach((rec: string) => {
+            console.log(`     • ${rec}`);
+          });
+        }
+      } else {
+        console.log(`📦 Framework detected: ${result.framework.name}`);
+      }
+      
+      if (result.framework.bundler) {
+        console.log(`🔧 Bundler: ${result.framework.bundler}`);
+      }
+      
+      if (result.framework.packageManager) {
+        console.log(`📋 Package Manager: ${result.framework.packageManager}`);
+      }
+
+      console.log('\n📝 Changes made:');
+      result.modifications.forEach((mod: any) => {
+        console.log(`   ${mod.action === 'create' ? '➕' : '✏️'}  ${mod.description}`);
+        console.log(`      ${mod.filePath}`);
+      });
+
+      console.log('\n🎯 Next steps:');
+      result.nextSteps.forEach((step: string) => {
+        console.log(`   ${step}`);
+      });
+
+      if (installationMode === 'ai' && result.learningData) {
+        console.log('\n🧠 Learning Data:');
+        console.log(`   Framework: ${result.learningData.framework}`);
+        console.log(`   Patterns: ${result.learningData.patterns.length} detected`);
+        console.log(`   Success: ${result.learningData.success ? 'Yes' : 'No'}`);
+      }
+
+      console.log('\n🚀 Your app is now ready to track user behavior!');
+      console.log('📊 View sessions in your HumanBehavior dashboard');
+      
+    } else {
+      console.log('\n❌ Installation failed:');
+      result.errors.forEach((error: string) => {
+        console.log(`   ${error}`);
+      });
+      
+      console.log('\n💡 Try running with --help for more options');
+    }
+  }
+}
+
+// CLI argument parsing
+function parseArgs(): AICLIOptions {
+  const args = process.argv.slice(2);
+  const options: AICLIOptions = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    if (arg === '--yes' || arg === '-y') {
+      options.yes = true;
+    } else if (arg === '--dry-run' || arg === '-d') {
+      options.dryRun = true;
+    } else if (arg === '--project' || arg === '-p') {
+      options.projectPath = args[i + 1];
+      i++;
+    } else if (arg === '--traditional' || arg === '-t') {
+      options.useAI = false;
+    } else if (arg === '--browser' || arg === '-b') {
+      options.browser = true;
+    } else if (arg === '--manual' || arg === '-m') {
+      options.manual = true;
+    } else if (arg === '--framework' || arg === '-f') {
+      options.framework = args[i + 1];
+      i++;
+    } else if (arg === '--help' || arg === '-h') {
+      showHelp();
+      process.exit(0);
+    } else if (!options.apiKey) {
+      options.apiKey = arg;
+    }
+  }
+
+  return options;
+}
+
+function showHelp() {
+  console.log(`
+AI-Enhanced HumanBehavior SDK Auto-Installation CLI
+
+Usage: npx humanbehavior-js ai-auto-install [api-key] [options]
+
+This tool uses AI to intelligently detect frameworks, analyze code patterns,
+and generate optimal integration code that's both future-proof and backward-compatible.
+
+Arguments:
+  api-key              Your HumanBehavior API key
+
+Options:
+  -y, --yes           Skip all prompts and use defaults
+  -d, --dry-run       Show what would be changed without making changes
+  -p, --project <path> Project directory (default: current directory)
+  -t, --traditional   Force traditional installation mode
+  -b, --browser       Browser-based AI installation
+  -m, --manual        Manual framework selection
+  -f, --framework <f> Specify framework for manual mode
+  -h, --help          Show this help message
+
+Installation Modes:
+  1. Manual AI-Enhanced (default): Choose your framework and use AI for optimization
+  2. Traditional: Standard framework detection and installation
+  3. Browser: Browser-based AI detection and code generation
+
+Examples:
+  npx humanbehavior-js ai-auto-install your-api-key
+  npx humanbehavior-js ai-auto-install your-api-key --manual --framework react
+  npx humanbehavior-js ai-auto-install your-api-key --traditional
+  npx humanbehavior-js ai-auto-install your-api-key --browser
+
+Supported Frameworks:
+  ✅ React (CRA, Vite, Webpack)
+  ✅ Next.js (App Router, Pages Router)
+  ✅ Vue (Vue CLI, Vite)
+  ✅ Angular
+  ✅ Svelte (SvelteKit, Vite)
+  ✅ Remix
+  ✅ Vanilla JS/TS
+  ✅ Node.js (CommonJS & ESM)
+
+AI Features:
+  🔍 Intelligent framework detection beyond package.json
+  📊 Code pattern analysis and optimization
+  🔄 Future-proof integration strategies
+  🔙 Backward compatibility with legacy frameworks
+  🧠 Learning from installation patterns
+  ⚡ Adaptive code generation for new frameworks
+  🔧 Smart conflict resolution
+  📈 Performance optimization recommendations
+
+The AI-enhanced tool will:
+1. 🔍 Analyze your codebase with AI to detect patterns
+2. 🎯 Determine optimal integration strategy
+3. 📦 Install the humanbehavior-js package
+4. ✏️  Generate AI-optimized integration code
+5. 🔧 Apply modifications with conflict resolution
+6. 🧠 Learn from the installation for future improvements
+7. 🚀 Make your app ready to track user behavior
+`);
+}
+
+// Main execution
+const options = parseArgs();
+
+// Check if we have enough arguments (api-key is required)
+if (process.argv.length < 3 || process.argv.includes('--help') || process.argv.includes('-h')) {
+  showHelp();
+  process.exit(0);
+}
+
+const cli = new AIAutoInstallCLI(options);
+cli.run().catch((error) => {
+  console.error('❌ Fatal error:', error);
+  process.exit(1);
+});
+
+export { AIAutoInstallCLI }; 

package/src/{cli → wizard/cli}/auto-install.ts

@@ -9,7 +9,7 @@
  * to integrate the SDK with minimal user intervention.
  */
 
-import { AutoInstallationWizard } from '../install-wizard';
+import { AutoInstallationWizard } from '../core/install-wizard';
 import * as readline from 'readline';
 import * as fs from 'fs';
 import * as path from 'path';

package/src/{install-wizard.ts → wizard/core/install-wizard.ts}

@@ -10,7 +10,7 @@ import * as path from 'path';
 
 export interface FrameworkInfo {
   name: string;
-  type: 'react' | 'vue' | 'angular' | 'svelte' | 'nextjs' | 'nuxt' | 'remix' | 'vanilla' | 'node';
+  type: 'react' | 'vue' | 'angular' | 'svelte' | 'nextjs' | 'nuxt' | 'remix' | 'vanilla' | 'node' | 'auto';
   bundler?: 'vite' | 'webpack' | 'esbuild' | 'rollup';
   packageManager?: 'npm' | 'yarn' | 'pnpm';
   hasTypeScript?: boolean;
@@ -34,9 +34,9 @@ export interface InstallationResult {
 }
 
 export class AutoInstallationWizard {
-  private apiKey: string;
-  private projectRoot: string;
-  private framework: FrameworkInfo | null = null;
+  protected apiKey: string;
+  protected projectRoot: string;
+  protected framework: FrameworkInfo | null = null;
 
   constructor(apiKey: string, projectRoot: string = process.cwd()) {
     this.apiKey = apiKey;
@@ -82,7 +82,7 @@ export class AutoInstallationWizard {
   /**
    * Detect the current framework and project setup
    */
-  private async detectFramework(): Promise<FrameworkInfo> {
+  public async detectFramework(): Promise<FrameworkInfo> {
     const packageJsonPath = path.join(this.projectRoot, 'package.json');
     
     if (!fs.existsSync(packageJsonPath)) {
@@ -190,7 +190,7 @@ export class AutoInstallationWizard {
   /**
    * Install the SDK package
    */
-  private async installPackage(): Promise<void> {
+  protected async installPackage(): Promise<void> {
     const { execSync } = await import('child_process');
     const command = this.framework?.packageManager === 'yarn' 
       ? 'yarn add humanbehavior-js'
@@ -208,7 +208,7 @@ export class AutoInstallationWizard {
   /**
    * Generate code modifications based on framework
    */
-  private async generateModifications(): Promise<CodeModification[]> {
+  protected async generateModifications(): Promise<CodeModification[]> {
     const modifications: CodeModification[] = [];
 
     switch (this.framework?.type) {
@@ -591,7 +591,7 @@ export default defineNuxtPlugin(() => {
   /**
    * Apply modifications to the codebase
    */
-  private async applyModifications(modifications: CodeModification[]): Promise<void> {
+  protected async applyModifications(modifications: CodeModification[]): Promise<void> {
     for (const modification of modifications) {
       try {
         const dir = path.dirname(modification.filePath);
@@ -1060,7 +1060,8 @@ if (typeof window !== 'undefined') {
         nuxt: 'NUXT_PUBLIC_HUMANBEHAVIOR_API_KEY',
         remix: 'HUMANBEHAVIOR_API_KEY',
         vanilla: 'HUMANBEHAVIOR_API_KEY',
-        node: 'HUMANBEHAVIOR_API_KEY'
+        node: 'HUMANBEHAVIOR_API_KEY',
+        auto: 'HUMANBEHAVIOR_API_KEY'
       };
       
       return envVarNames[framework.type] || 'HUMANBEHAVIOR_API_KEY';
@@ -1086,7 +1087,8 @@ if (typeof window !== 'undefined') {
       nuxt: '.env',
       remix: '.env.local',
       vanilla: '.env',
-      node: '.env'
+      node: '.env',
+      auto: '.env'
     };
 
     const defaultFile = defaultFiles[framework.type] || '.env';