humanbehavior-js 0.4.13 → 0.4.15

package/dist/cli/ai-auto-install.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import * as fs from 'fs';
 import * as path from 'path';
-import * as readline from 'readline';
+import * as clack from '@clack/prompts';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -47,6 +47,28 @@ class AutoInstallationWizard {
         this.apiKey = apiKey;
         this.projectRoot = projectRoot;
     }
+    /**
+     * Simple version comparison utility
+     */
+    compareVersions(version1, version2) {
+        const v1Parts = version1.split('.').map(Number);
+        const v2Parts = version2.split('.').map(Number);
+        for (let i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
+            const v1 = v1Parts[i] || 0;
+            const v2 = v2Parts[i] || 0;
+            if (v1 > v2)
+                return 1;
+            if (v1 < v2)
+                return -1;
+        }
+        return 0;
+    }
+    isVersionGte(version, target) {
+        return this.compareVersions(version, target) >= 0;
+    }
+    getMajorVersion(version) {
+        return parseInt(version.split('.')[0]) || 0;
+    }
     /**
      * Main installation method - detects framework and auto-installs
      */
@@ -96,73 +118,146 @@ class AutoInstallationWizard {
             }
             const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
             const dependencies = Object.assign(Object.assign({}, packageJson.dependencies), packageJson.devDependencies);
-            // Detect framework
+            // Detect framework with version information
             let framework = {
                 name: 'vanilla',
                 type: 'vanilla',
-                projectRoot: this.projectRoot
+                projectRoot: this.projectRoot,
+                features: {}
             };
             if (dependencies.nuxt) {
+                const nuxtVersion = dependencies.nuxt;
+                const isNuxt3 = this.isVersionGte(nuxtVersion, '3.0.0');
                 framework = {
                     name: 'nuxt',
                     type: 'nuxt',
+                    version: nuxtVersion,
+                    majorVersion: this.getMajorVersion(nuxtVersion),
                     hasTypeScript: !!dependencies.typescript,
                     hasRouter: true,
-                    projectRoot: this.projectRoot
+                    projectRoot: this.projectRoot,
+                    features: {
+                        hasNuxt3: isNuxt3
+                    }
                 };
             }
             else if (dependencies.next) {
+                const nextVersion = dependencies.next;
+                const isNext13 = this.isVersionGte(nextVersion, '13.0.0');
                 framework = {
                     name: 'nextjs',
                     type: 'nextjs',
+                    version: nextVersion,
+                    majorVersion: this.getMajorVersion(nextVersion),
                     hasTypeScript: !!dependencies.typescript || !!dependencies['@types/node'],
                     hasRouter: true,
-                    projectRoot: this.projectRoot
+                    projectRoot: this.projectRoot,
+                    features: {
+                        hasNextAppRouter: isNext13
+                    }
                 };
             }
             else if (dependencies['@remix-run/react'] || dependencies['@remix-run/dev']) {
+                const remixVersion = dependencies['@remix-run/react'] || dependencies['@remix-run/dev'];
                 framework = {
                     name: 'remix',
                     type: 'remix',
+                    version: remixVersion,
+                    majorVersion: this.getMajorVersion(remixVersion),
                     hasTypeScript: !!dependencies.typescript || !!dependencies['@types/react'],
                     hasRouter: true,
-                    projectRoot: this.projectRoot
+                    projectRoot: this.projectRoot,
+                    features: {}
                 };
             }
             else if (dependencies.react) {
+                const reactVersion = dependencies.react;
+                const isReact18 = this.isVersionGte(reactVersion, '18.0.0');
                 framework = {
                     name: 'react',
                     type: 'react',
+                    version: reactVersion,
+                    majorVersion: this.getMajorVersion(reactVersion),
                     hasTypeScript: !!dependencies.typescript || !!dependencies['@types/react'],
                     hasRouter: !!dependencies['react-router-dom'] || !!dependencies['react-router'],
-                    projectRoot: this.projectRoot
+                    projectRoot: this.projectRoot,
+                    features: {
+                        hasReact18: isReact18
+                    }
                 };
             }
             else if (dependencies.vue) {
+                const vueVersion = dependencies.vue;
+                const isVue3 = this.isVersionGte(vueVersion, '3.0.0');
                 framework = {
                     name: 'vue',
                     type: 'vue',
+                    version: vueVersion,
+                    majorVersion: this.getMajorVersion(vueVersion),
                     hasTypeScript: !!dependencies.typescript || !!dependencies['@vue/cli-service'],
                     hasRouter: !!dependencies['vue-router'],
-                    projectRoot: this.projectRoot
+                    projectRoot: this.projectRoot,
+                    features: {
+                        hasVue3: isVue3
+                    }
                 };
             }
             else if (dependencies['@angular/core']) {
+                const angularVersion = dependencies['@angular/core'];
+                const isAngular17 = this.isVersionGte(angularVersion, '17.0.0');
                 framework = {
                     name: 'angular',
                     type: 'angular',
+                    version: angularVersion,
+                    majorVersion: this.getMajorVersion(angularVersion),
                     hasTypeScript: true,
                     hasRouter: true,
-                    projectRoot: this.projectRoot
+                    projectRoot: this.projectRoot,
+                    features: {
+                        hasAngularStandalone: isAngular17
+                    }
                 };
             }
             else if (dependencies.svelte) {
+                const svelteVersion = dependencies.svelte;
+                const isSvelteKit = !!dependencies['@sveltejs/kit'];
                 framework = {
                     name: 'svelte',
                     type: 'svelte',
+                    version: svelteVersion,
+                    majorVersion: this.getMajorVersion(svelteVersion),
                     hasTypeScript: !!dependencies.typescript || !!dependencies['svelte-check'],
                     hasRouter: !!dependencies['svelte-routing'] || !!dependencies['@sveltejs/kit'],
-                    projectRoot: this.projectRoot
+                    projectRoot: this.projectRoot,
+                    features: {
+                        hasSvelteKit: isSvelteKit
+                    }
+                };
+            }
+            else if (dependencies.astro) {
+                const astroVersion = dependencies.astro;
+                framework = {
+                    name: 'astro',
+                    type: 'astro',
+                    version: astroVersion,
+                    majorVersion: this.getMajorVersion(astroVersion),
+                    hasTypeScript: !!dependencies.typescript || !!dependencies['@astrojs/ts-plugin'],
+                    hasRouter: true,
+                    projectRoot: this.projectRoot,
+                    features: {}
+                };
+            }
+            else if (dependencies.gatsby) {
+                const gatsbyVersion = dependencies.gatsby;
+                framework = {
+                    name: 'gatsby',
+                    type: 'gatsby',
+                    version: gatsbyVersion,
+                    majorVersion: this.getMajorVersion(gatsbyVersion),
+                    hasTypeScript: !!dependencies.typescript || !!dependencies['@types/react'],
+                    hasRouter: true,
+                    projectRoot: this.projectRoot,
+                    features: {}
                 };
             }
             // Detect bundler
@@ -196,13 +291,18 @@ class AutoInstallationWizard {
      */
     installPackage() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c, _d;
             const { execSync } = yield import('child_process');
-            const command = ((_a = this.framework) === null || _a === void 0 ? void 0 : _a.packageManager) === 'yarn'
+            // Build base command
+            let command = ((_a = this.framework) === null || _a === void 0 ? void 0 : _a.packageManager) === 'yarn'
                 ? 'yarn add humanbehavior-js'
                 : ((_b = this.framework) === null || _b === void 0 ? void 0 : _b.packageManager) === 'pnpm'
                     ? 'pnpm add humanbehavior-js'
                     : 'npm install humanbehavior-js';
+            // Add legacy peer deps flag for npm to handle dependency conflicts
+            if (((_c = this.framework) === null || _c === void 0 ? void 0 : _c.packageManager) !== 'yarn' && ((_d = this.framework) === null || _d === void 0 ? void 0 : _d.packageManager) !== 'pnpm') {
+                command += ' --legacy-peer-deps';
+            }
             try {
                 execSync(command, { cwd: this.projectRoot, stdio: 'inherit' });
             }
@@ -228,6 +328,12 @@ class AutoInstallationWizard {
                 case 'nuxt':
                     modifications.push(...yield this.generateNuxtModifications());
                     break;
+                case 'astro':
+                    modifications.push(...yield this.generateAstroModifications());
+                    break;
+                case 'gatsby':
+                    modifications.push(...yield this.generateGatsbyModifications());
+                    break;
                 case 'remix':
                     modifications.push(...yield this.generateRemixModifications());
                     break;
@@ -339,6 +445,84 @@ export function Providers({ children }: { children: React.ReactNode }) {
             return modifications;
         });
     }
+    /**
+     * Generate Astro-specific modifications
+     */
+    generateAstroModifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modifications = [];
+            // Create Astro component for HumanBehavior
+            const astroComponentPath = path.join(this.projectRoot, 'src', 'components', 'HumanBehavior.astro');
+            const astroComponentContent = `---
+// This component will only run on the client side
+---
+
+<script>
+  import { HumanBehaviorTracker } from 'humanbehavior-js';
+  
+  // Get API key from environment variable
+  const apiKey = import.meta.env.PUBLIC_HUMANBEHAVIOR_API_KEY;
+  
+  console.log('HumanBehavior: API key found:', apiKey ? 'Yes' : 'No');
+  
+  if (apiKey) {
+    try {
+      const tracker = HumanBehaviorTracker.init(apiKey);
+      console.log('HumanBehavior: Tracker initialized successfully');
+      
+      // Test event to verify tracking is working
+      setTimeout(() => {
+        tracker.customEvent('astro_page_view', {
+          page: window.location.pathname,
+          framework: 'astro'
+        }).then(() => {
+          console.log('HumanBehavior: Test event sent successfully');
+        }).catch((error) => {
+          console.error('HumanBehavior: Failed to send test event:', error);
+        });
+      }, 1000);
+      
+    } catch (error) {
+      console.error('HumanBehavior: Failed to initialize tracker:', error);
+    }
+  } else {
+    console.error('HumanBehavior: No API key found');
+  }
+</script>`;
+            modifications.push({
+                filePath: astroComponentPath,
+                action: 'create',
+                content: astroComponentContent,
+                description: 'Created Astro component for HumanBehavior SDK'
+            });
+            // Find and update layout file
+            const layoutFiles = [
+                path.join(this.projectRoot, 'src', 'layouts', 'Layout.astro'),
+                path.join(this.projectRoot, 'src', 'layouts', 'layout.astro'),
+                path.join(this.projectRoot, 'src', 'layouts', 'BaseLayout.astro')
+            ];
+            let layoutFile = null;
+            for (const file of layoutFiles) {
+                if (fs.existsSync(file)) {
+                    layoutFile = file;
+                    break;
+                }
+            }
+            if (layoutFile) {
+                const content = fs.readFileSync(layoutFile, 'utf8');
+                const modifiedContent = this.injectAstroLayout(content);
+                modifications.push({
+                    filePath: layoutFile,
+                    action: 'modify',
+                    content: modifiedContent,
+                    description: 'Added HumanBehavior component to Astro layout'
+                });
+            }
+            // Add environment variable
+            modifications.push(this.createEnvironmentModification(this.framework));
+            return modifications;
+        });
+    }
     /**
      * Generate Nuxt-specific modifications
      */
@@ -559,6 +743,50 @@ export default defineNuxtPlugin(() => {
             return modifications;
         });
     }
+    /**
+     * Generate Gatsby-specific modifications
+     */
+    generateGatsbyModifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modifications = [];
+            // Modify or create gatsby-browser.js for Gatsby
+            const gatsbyBrowserFile = path.join(this.projectRoot, 'gatsby-browser.js');
+            if (fs.existsSync(gatsbyBrowserFile)) {
+                const content = fs.readFileSync(gatsbyBrowserFile, 'utf8');
+                const modifiedContent = this.injectGatsbyBrowser(content);
+                modifications.push({
+                    filePath: gatsbyBrowserFile,
+                    action: 'modify',
+                    content: modifiedContent,
+                    description: 'Added HumanBehavior initialization to Gatsby browser'
+                });
+            }
+            else {
+                // Create gatsby-browser.js if it doesn't exist
+                modifications.push({
+                    filePath: gatsbyBrowserFile,
+                    action: 'create',
+                    content: `import { HumanBehaviorTracker } from 'humanbehavior-js';
+
+export const onClientEntry = () => {
+  console.log('Gatsby browser entry point loaded');
+  const apiKey = process.env.GATSBY_HUMANBEHAVIOR_API_KEY;
+  console.log('API Key found:', apiKey ? 'Yes' : 'No');
+  if (apiKey) {
+    const tracker = HumanBehaviorTracker.init(apiKey);
+    console.log('HumanBehavior SDK initialized for Gatsby');
+  } else {
+    console.log('No API key found in environment variables');
+  }
+};`,
+                    description: 'Created gatsby-browser.js with HumanBehavior initialization'
+                });
+            }
+            // Create or append to environment file
+            modifications.push(this.createEnvironmentModification(this.framework));
+            return modifications;
+        });
+    }
     /**
      * Apply modifications to the codebase
      */
@@ -653,7 +881,7 @@ export default defineNuxtPlugin(() => {
         return null;
     }
     injectReactProvider(content, filePath) {
-        var _a;
+        var _a, _b, _c;
         filePath.endsWith('.tsx') || filePath.endsWith('.ts');
         // Check if already has HumanBehaviorProvider
         if (content.includes('HumanBehaviorProvider')) {
@@ -665,14 +893,39 @@ export default defineNuxtPlugin(() => {
             ? 'import.meta.env.VITE_HUMANBEHAVIOR_API_KEY!'
             : 'process.env.HUMANBEHAVIOR_API_KEY!';
         const importStatement = `import { HumanBehaviorProvider } from 'humanbehavior-js/react';`;
-        // Simple injection - in production, you'd want more sophisticated parsing
+        // Enhanced parsing for React 18+ features
+        const hasReact18 = (_c = (_b = this.framework) === null || _b === void 0 ? void 0 : _b.features) === null || _c === void 0 ? void 0 : _c.hasReact18;
+        // Handle different React patterns
         if (content.includes('function App()') || content.includes('const App =')) {
-            return content.replace(/(function App\(\)|const App =)/, `${importStatement}\n\n$1`).replace(/return \(([\s\S]*?)\);/, `return (
+            // Add import statement
+            let modifiedContent = content.replace(/(import.*?from.*?['"]react['"];?)/, `$1\n${importStatement}`);
+            // If no React import found, add it at the top
+            if (!modifiedContent.includes(importStatement)) {
+                modifiedContent = `${importStatement}\n\n${modifiedContent}`;
+            }
+            // Wrap the App component return with HumanBehaviorProvider
+            modifiedContent = modifiedContent.replace(/(return\s*\([\s\S]*?\)\s*;)/, `return (
     <HumanBehaviorProvider apiKey={${envVar}}>
       $1
     </HumanBehaviorProvider>
   );`);
+            return modifiedContent;
         }
+        // Handle React 18+ createRoot pattern
+        if (hasReact18 && content.includes('createRoot')) {
+            let modifiedContent = content.replace(/(import.*?from.*?['"]react['"];?)/, `$1\n${importStatement}`);
+            if (!modifiedContent.includes(importStatement)) {
+                modifiedContent = `${importStatement}\n\n${modifiedContent}`;
+            }
+            // Wrap the root render with HumanBehaviorProvider
+            modifiedContent = modifiedContent.replace(/(root\.render\s*\([\s\S]*?\)\s*;)/, `root.render(
+    <HumanBehaviorProvider apiKey={${envVar}}>
+      $1
+    </HumanBehaviorProvider>
+  );`);
+            return modifiedContent;
+        }
+        // Fallback: simple injection
         return `${importStatement}\n\n${content}`;
     }
     injectNextJSAppRouter(content) {
@@ -769,21 +1022,51 @@ export default function App()`);
         return modifiedContent;
     }
     injectVuePlugin(content) {
+        var _a, _b;
         if (content.includes('HumanBehaviorPlugin')) {
             return content;
         }
         const importStatement = `import { HumanBehaviorPlugin } from 'humanbehavior-js/vue';`;
-        const pluginUsage = `app.use(HumanBehaviorPlugin, {
+        // Enhanced Vue 3 support with version detection
+        const hasVue3 = (_b = (_a = this.framework) === null || _a === void 0 ? void 0 : _a.features) === null || _b === void 0 ? void 0 : _b.hasVue3;
+        if (hasVue3) {
+            // Vue 3 with Composition API
+            const pluginUsage = `app.use(HumanBehaviorPlugin, {
   apiKey: import.meta.env.VITE_HUMANBEHAVIOR_API_KEY
 });`;
-        // Handle both Vue 2 and Vue 3 patterns
-        if (content.includes('createApp')) {
-            // Vue 3
-            return content.replace(/import.*from.*['"]vue['"]/, `$&\n${importStatement}`).replace(/app\.mount\(/, `${pluginUsage}\n\napp.mount(`);
+            let modifiedContent = content;
+            // Add import statement
+            if (!content.includes(importStatement)) {
+                modifiedContent = content.replace(/(import.*?from.*?['"]vue['"];?)/, `$1\n${importStatement}`);
+                // If no Vue import found, add it at the top
+                if (!modifiedContent.includes(importStatement)) {
+                    modifiedContent = `${importStatement}\n\n${modifiedContent}`;
+                }
+            }
+            // Handle createApp pattern
+            if (content.includes('createApp')) {
+                modifiedContent = modifiedContent.replace(/(app\.mount\(.*?\))/, `${pluginUsage}\n\n$1`);
+            }
+            return modifiedContent;
         }
         else {
-            // Vue 2
-            return content.replace(/import.*from.*['"]vue['"]/, `$&\n${importStatement}`).replace(/new Vue\(/, `${pluginUsage}\n\nnew Vue(`);
+            // Vue 2 with Options API
+            const pluginUsage = `Vue.use(HumanBehaviorPlugin, {
+  apiKey: process.env.VUE_APP_HUMANBEHAVIOR_API_KEY
+});`;
+            let modifiedContent = content;
+            // Add import statement
+            if (!content.includes(importStatement)) {
+                modifiedContent = content.replace(/(import.*?from.*?['"]vue['"];?)/, `$1\n${importStatement}`);
+                if (!modifiedContent.includes(importStatement)) {
+                    modifiedContent = `${importStatement}\n\n${modifiedContent}`;
+                }
+            }
+            // Handle new Vue pattern
+            if (content.includes('new Vue')) {
+                modifiedContent = modifiedContent.replace(/(new Vue\(.*?\))/, `${pluginUsage}\n\n$1`);
+            }
+            return modifiedContent;
         }
     }
     injectAngularModule(content) {
@@ -864,17 +1147,99 @@ if (typeof window !== 'undefined') {
 </script>`;
         return content.replace(/<\/head>/, `  ${cdnScript}\n  ${initScript}\n</head>`);
     }
+    /**
+     * Inject Astro layout with HumanBehavior component
+     */
+    injectAstroLayout(content) {
+        // Check if HumanBehavior component is already imported
+        if (content.includes('HumanBehavior') || content.includes('humanbehavior-js')) {
+            return content; // Already has HumanBehavior
+        }
+        // Add import inside frontmatter if not present
+        let modifiedContent = content;
+        if (!content.includes('import HumanBehavior')) {
+            const importStatement = 'import HumanBehavior from \'../components/HumanBehavior.astro\';';
+            const frontmatterEndIndex = content.indexOf('---', 3);
+            if (frontmatterEndIndex !== -1) {
+                // Insert import inside frontmatter, before the closing ---
+                modifiedContent = content.slice(0, frontmatterEndIndex) + '\n' + importStatement + '\n' + content.slice(frontmatterEndIndex);
+            }
+            else {
+                // No frontmatter, add at the very beginning
+                modifiedContent = '---\n' + importStatement + '\n---\n\n' + content;
+            }
+        }
+        // Find the closing </body> tag and add HumanBehavior component before it
+        const bodyCloseIndex = modifiedContent.lastIndexOf('</body>');
+        if (bodyCloseIndex === -1) {
+            // No body tag found, append to end
+            return modifiedContent + '\n\n<HumanBehavior />';
+        }
+        // Add component before closing body tag
+        return modifiedContent.slice(0, bodyCloseIndex) + '  <HumanBehavior />\n' + modifiedContent.slice(bodyCloseIndex);
+    }
     injectNuxtConfig(content) {
+        var _a, _b;
         if (content.includes('humanBehaviorApiKey')) {
             return content;
         }
-        // Add runtime config by inserting it after the opening brace
-        return content.replace(/export default defineNuxtConfig\(\{/, `export default defineNuxtConfig({
+        // Enhanced Nuxt 3 support with version detection
+        const hasNuxt3 = (_b = (_a = this.framework) === null || _a === void 0 ? void 0 : _a.features) === null || _b === void 0 ? void 0 : _b.hasNuxt3;
+        if (hasNuxt3) {
+            // Nuxt 3 with runtime config
+            return content.replace(/export default defineNuxtConfig\(\{/, `export default defineNuxtConfig({
   runtimeConfig: {
     public: {
       humanBehaviorApiKey: process.env.NUXT_PUBLIC_HUMANBEHAVIOR_API_KEY
     }
   },`);
+        }
+        else {
+            // Nuxt 2 with env config
+            return content.replace(/export default \{/, `export default {
+  env: {
+    humanBehaviorApiKey: process.env.HUMANBEHAVIOR_API_KEY
+  },`);
+        }
+    }
+    injectGatsbyLayout(content) {
+        if (content.includes('HumanBehavior')) {
+            return content;
+        }
+        const importStatement = `import HumanBehavior from './HumanBehavior';`;
+        const componentUsage = `<HumanBehavior apiKey={process.env.GATSBY_HUMANBEHAVIOR_API_KEY || ''} />`;
+        // Add import at the top
+        let modifiedContent = content.replace(/import.*from.*['"]\./, `${importStatement}\n$&`);
+        // Add component before closing body tag
+        modifiedContent = modifiedContent.replace(/(\s*<\/body>)/, `\n      ${componentUsage}\n$1`);
+        return modifiedContent;
+    }
+    injectGatsbyBrowser(content) {
+        if (content.includes('HumanBehaviorTracker')) {
+            return content;
+        }
+        const importStatement = `import { HumanBehaviorTracker } from 'humanbehavior-js';`;
+        const initCode = `
+// Initialize HumanBehavior SDK
+export const onClientEntry = () => {
+  console.log('Gatsby browser entry point loaded');
+  const apiKey = process.env.GATSBY_HUMANBEHAVIOR_API_KEY;
+  console.log('API Key found:', apiKey ? 'Yes' : 'No');
+  if (apiKey) {
+    const tracker = HumanBehaviorTracker.init(apiKey);
+    console.log('HumanBehavior SDK initialized for Gatsby');
+  } else {
+    console.log('No API key found in environment variables');
+  }
+};`;
+        // If the file already has content, add the import and init code
+        if (content.trim()) {
+            return `${importStatement}${initCode}\n\n${content}`;
+        }
+        else {
+            // If file is empty, just return the new content
+            return `${importStatement}${initCode}`;
+        }
     }
     /**
      * Helper method to find the best environment file for a framework
@@ -905,6 +1270,8 @@ if (typeof window !== 'undefined') {
                 nuxt: 'NUXT_PUBLIC_HUMANBEHAVIOR_API_KEY',
                 remix: 'HUMANBEHAVIOR_API_KEY',
                 vanilla: 'HUMANBEHAVIOR_API_KEY',
+                astro: 'PUBLIC_HUMANBEHAVIOR_API_KEY',
+                gatsby: 'GATSBY_HUMANBEHAVIOR_API_KEY',
                 node: 'HUMANBEHAVIOR_API_KEY',
                 auto: 'HUMANBEHAVIOR_API_KEY'
             };
@@ -928,6 +1295,8 @@ if (typeof window !== 'undefined') {
             nuxt: '.env',
             remix: '.env.local',
             vanilla: '.env',
+            astro: '.env',
+            gatsby: '.env.development',
             node: '.env',
             auto: '.env'
         };
@@ -942,6 +1311,8 @@ if (typeof window !== 'undefined') {
      */
     createEnvironmentModification(framework) {
         const { filePath, envVarName } = this.findBestEnvFile(framework);
+        // Clean the API key to prevent formatting issues
+        const cleanApiKey = this.apiKey.trim();
         if (fs.existsSync(filePath)) {
             // Check if the variable already exists
             const content = fs.readFileSync(filePath, 'utf8');
@@ -959,7 +1330,7 @@ if (typeof window !== 'undefined') {
                 return {
                     filePath,
                     action: 'append',
-                    content: `\n${envVarName}=${this.apiKey}`,
+                    content: `\n${envVarName}=${cleanApiKey}`,
                     description: `Added API key to existing ${path.basename(filePath)}`
                 };
             }
@@ -969,309 +1340,13 @@ if (typeof window !== 'undefined') {
             return {
                 filePath,
                 action: 'create',
-                content: `${envVarName}=${this.apiKey}`,
+                content: `${envVarName}=${cleanApiKey}`,
                 description: `Created ${path.basename(filePath)} with API key`
             };
         }
     }
 }
 
-/**
- * AI-Enhanced HumanBehavior SDK Auto-Installation Wizard
- *
- * This wizard uses AI to intelligently detect frameworks, analyze code patterns,
- * and generate optimal integration code that's both future-proof and backward-compatible.
- *
- * 🚀 KEY FEATURES:
- * - AI-powered framework detection beyond package.json
- * - Intelligent code pattern analysis
- * - Future-proof integration strategies
- * - Backward compatibility with legacy frameworks
- * - Adaptive code generation for new frameworks
- * - Smart conflict resolution
- * - Learning from user feedback
- * - Centralized AI service (no user API keys required)
- */
-/**
- * Default AI Service Implementation
- * Uses heuristic analysis when centralized service is not available
- */
-class DefaultAIService {
-    analyzeCodePatterns(codeSamples) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.analyzeWithHeuristics(codeSamples);
-        });
-    }
-    resolveConflicts(conflicts, framework) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Default conflict resolution strategies
-            const resolutions = [];
-            for (const conflict of conflicts) {
-                switch (conflict) {
-                    case 'existing_humanbehavior_code':
-                        resolutions.push('update_existing_integration');
-                        break;
-                    case 'existing_provider':
-                        resolutions.push('merge_providers');
-                        break;
-                    case 'module_system_conflict':
-                        resolutions.push('hybrid_module_support');
-                        break;
-                    default:
-                        resolutions.push('skip_conflict');
-                }
-            }
-            return resolutions;
-        });
-    }
-    generateOptimizations(framework, patterns) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const optimizations = [];
-            // Framework-specific optimizations
-            switch (framework.type) {
-                case 'react':
-                    optimizations.push('Use React.memo for performance optimization');
-                    optimizations.push('Implement error boundaries for better error tracking');
-                    optimizations.push('Consider using React.lazy for code splitting');
-                    break;
-                case 'vue':
-                    optimizations.push('Use Vue 3 Composition API for better performance');
-                    optimizations.push('Implement proper error handling in components');
-                    optimizations.push('Consider using Vue Router for navigation tracking');
-                    break;
-                case 'angular':
-                    optimizations.push('Use Angular standalone components for better tree-shaking');
-                    optimizations.push('Implement proper error handling with ErrorHandler');
-                    optimizations.push('Consider using Angular signals for state management');
-                    break;
-                default:
-                    optimizations.push('Enable performance tracking');
-                    optimizations.push('Implement error tracking');
-                    optimizations.push('Consider progressive enhancement');
-            }
-            return optimizations;
-        });
-    }
-    analyzeWithHeuristics(codeSamples) {
-        const patterns = codeSamples.join(' ').toLowerCase();
-        // Framework detection
-        let framework = { name: 'vanilla', type: 'vanilla' };
-        let confidence = 0.5;
-        if (patterns.includes('nuxt') || patterns.includes('nuxtjs') || patterns.includes('defineNuxtConfig') || patterns.includes('nuxt.config') || patterns.includes('@nuxt/') || patterns.includes('useNuxtApp') || patterns.includes('useRuntimeConfig') || patterns.includes('useSeoMeta') || patterns.includes('useHead') || patterns.includes('useLazyFetch') || patterns.includes('useFetch') || patterns.includes('useAsyncData') || patterns.includes('#app')) {
-            framework = { name: 'nuxt', type: 'nuxt' };
-            confidence = 0.95;
-        }
-        else if (patterns.includes('next') || patterns.includes('nextjs') || patterns.includes('next/link') || patterns.includes('next/image') || patterns.includes('next/navigation') || patterns.includes('next/router') || patterns.includes('getserverSideProps') || patterns.includes('getstaticProps') || patterns.includes('getstaticPaths') || patterns.includes('app/layout') || patterns.includes('app/page') || patterns.includes('pages/')) {
-            framework = { name: 'nextjs', type: 'nextjs' };
-            confidence = 0.95;
-        }
-        else if (patterns.includes('react')) {
-            framework = { name: 'react', type: 'react' };
-            confidence = 0.9;
-        }
-        else if (patterns.includes('vue')) {
-            framework = { name: 'vue', type: 'vue' };
-            confidence = 0.9;
-        }
-        else if (patterns.includes('angular')) {
-            framework = { name: 'angular', type: 'angular' };
-            confidence = 0.9;
-        }
-        else if (patterns.includes('svelte')) {
-            framework = { name: 'svelte', type: 'svelte' };
-            confidence = 0.9;
-        }
-        // Integration strategy
-        let integrationStrategy = 'script';
-        if (framework.type === 'react' || framework.type === 'nextjs') {
-            integrationStrategy = 'provider';
-        }
-        else if (framework.type === 'vue') {
-            integrationStrategy = 'plugin';
-        }
-        else if (framework.type === 'angular') {
-            integrationStrategy = 'module';
-        }
-        // Compatibility mode
-        let compatibilityMode = 'modern';
-        if (patterns.includes('require(') || patterns.includes('var ')) {
-            compatibilityMode = 'legacy';
-        }
-        return {
-            framework,
-            confidence,
-            patterns: codeSamples,
-            conflicts: [],
-            recommendations: [],
-            integrationStrategy,
-            compatibilityMode
-        };
-    }
-}
-/**
- * Browser-based AI installation wizard
- */
-class AIBrowserInstallationWizard {
-    constructor(apiKey, aiService) {
-        this.apiKey = apiKey;
-        this.aiService = aiService || new DefaultAIService();
-    }
-    install() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // AI-powered browser detection
-                const aiAnalysis = yield this.performBrowserAIAnalysis();
-                // Generate AI-optimized browser modifications
-                const modifications = this.generateAIBrowserModifications(aiAnalysis);
-                return {
-                    success: true,
-                    framework: aiAnalysis.framework,
-                    modifications,
-                    errors: [],
-                    nextSteps: [
-                        '✅ AI-optimized browser integration ready!',
-                        `🎯 Framework detected: ${aiAnalysis.framework.name}`,
-                        `🔧 Integration strategy: ${aiAnalysis.integrationStrategy}`,
-                        '📋 Copy the generated code to your project',
-                        '🚀 Your app will be ready to track user behavior'
-                    ],
-                    aiAnalysis,
-                    learningData: {
-                        patterns: aiAnalysis.patterns,
-                        framework: aiAnalysis.framework.name,
-                        success: true
-                    }
-                };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    framework: { name: 'unknown', type: 'vanilla' },
-                    modifications: [],
-                    errors: [error instanceof Error ? error.message : 'Unknown error'],
-                    nextSteps: [],
-                    aiAnalysis: {
-                        framework: { name: 'unknown', type: 'vanilla' },
-                        confidence: 0,
-                        patterns: [],
-                        conflicts: [],
-                        recommendations: [],
-                        integrationStrategy: 'script',
-                        compatibilityMode: 'legacy'
-                    },
-                    learningData: {
-                        patterns: [],
-                        framework: 'unknown',
-                        success: false
-                    }
-                };
-            }
-        });
-    }
-    performBrowserAIAnalysis() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Browser-based framework detection
-            this.detectBrowserFramework();
-            // Analyze browser environment
-            const patterns = this.analyzeBrowserPatterns();
-            // Use centralized AI service for analysis
-            const codeSamples = [`Browser Environment: ${patterns.join(', ')}`];
-            return yield this.aiService.analyzeCodePatterns(codeSamples);
-        });
-    }
-    detectBrowserFramework() {
-        if (typeof window !== 'undefined') {
-            if (window.React) {
-                return { name: 'react', type: 'react' };
-            }
-            if (window.Vue) {
-                return { name: 'vue', type: 'vue' };
-            }
-            if (window.angular) {
-                return { name: 'angular', type: 'angular' };
-            }
-        }
-        return { name: 'vanilla', type: 'vanilla' };
-    }
-    analyzeBrowserPatterns() {
-        const patterns = [];
-        if (typeof window !== 'undefined') {
-            // Analyze global objects
-            if (window.React)
-                patterns.push('React global detected');
-            if (window.Vue)
-                patterns.push('Vue global detected');
-            if (window.angular)
-                patterns.push('Angular global detected');
-            // Analyze DOM patterns
-            if (document.querySelector('[data-reactroot]'))
-                patterns.push('React DOM detected');
-            if (document.querySelector('[data-vue]'))
-                patterns.push('Vue DOM detected');
-            // Analyze script patterns
-            const scripts = document.querySelectorAll('script');
-            scripts.forEach(script => {
-                if (script.src.includes('react'))
-                    patterns.push('React script detected');
-                if (script.src.includes('vue'))
-                    patterns.push('Vue script detected');
-            });
-        }
-        return patterns;
-    }
-    generateAIBrowserModifications(aiAnalysis) {
-        const modifications = [];
-        switch (aiAnalysis.framework.type) {
-            case 'react':
-                modifications.push({
-                    filePath: 'App.jsx',
-                    action: 'create',
-                    content: `// AI-Optimized React Integration
-import { HumanBehaviorProvider } from 'humanbehavior-js/react';
-
-function App() {
-  return (
-    <HumanBehaviorProvider 
-      apiKey="${this.apiKey}"
-      config={{
-        // AI-generated optimizations
-        enablePerformanceTracking: true,
-        enableErrorTracking: true,
-        framework: '${aiAnalysis.framework.name}',
-        integrationStrategy: '${aiAnalysis.integrationStrategy}'
-      }}
-    >
-      {/* Your app components */}
-    </HumanBehaviorProvider>
-  );
-}
-
-export default App;`,
-                    description: 'AI-optimized React component with HumanBehaviorProvider'
-                });
-                break;
-            default:
-                modifications.push({
-                    filePath: 'humanbehavior-init.js',
-                    action: 'create',
-                    content: `// AI-Optimized Vanilla JS Integration
-import { HumanBehaviorTracker } from 'humanbehavior-js';
-
-const tracker = HumanBehaviorTracker.init('${this.apiKey}', {
-  // AI-generated configuration
-  framework: '${aiAnalysis.framework.name}',
-  integrationStrategy: '${aiAnalysis.integrationStrategy}',
-  compatibilityMode: '${aiAnalysis.compatibilityMode}',
-  enablePerformanceTracking: true,
-  enableErrorTracking: true
-});`,
-                    description: 'AI-optimized vanilla JS initialization'
-                });
-        }
-        return modifications;
-    }
-}
-
 /**
  * Remote AI Service Implementation
  *
@@ -1375,6 +1450,10 @@ class RemoteAIService {
             framework = { name: 'nextjs', type: 'nextjs' };
             confidence = 0.95;
         }
+        else if (patterns.includes('gatsby') || patterns.includes('gatsby-browser') || patterns.includes('gatsby-ssr') || patterns.includes('gatsby-node') || patterns.includes('gatsby-config') || patterns.includes('useStaticQuery') || patterns.includes('graphql')) {
+            framework = { name: 'gatsby', type: 'gatsby' };
+            confidence = 0.95;
+        }
         else if (patterns.includes('react')) {
             framework = { name: 'react', type: 'react' };
             confidence = 0.9;
@@ -1391,9 +1470,13 @@ class RemoteAIService {
             framework = { name: 'svelte', type: 'svelte' };
             confidence = 0.9;
         }
+        else if (patterns.includes('astro')) {
+            framework = { name: 'astro', type: 'astro' };
+            confidence = 0.9;
+        }
         // Integration strategy
         let integrationStrategy = 'script';
-        if (framework.type === 'react' || framework.type === 'nextjs') {
+        if (framework.type === 'react' || framework.type === 'nextjs' || framework.type === 'gatsby') {
             integrationStrategy = 'provider';
         }
         else if (framework.type === 'vue') {
@@ -1636,6 +1719,8 @@ class ManualFrameworkInstallationWizard extends AutoInstallationWizard {
             'svelte': { name: 'svelte', type: 'svelte' },
             'sveltekit': { name: 'svelte', type: 'svelte' },
             'remix': { name: 'remix', type: 'remix' },
+            'astro': { name: 'astro', type: 'astro' },
+            'gatsby': { name: 'gatsby', type: 'gatsby' },
             'vanilla': { name: 'vanilla', type: 'vanilla' },
             'node': { name: 'node', type: 'node' },
             'auto': { name: 'auto-detected', type: 'auto' }
@@ -1695,67 +1780,46 @@ class ManualFrameworkInstallationWizard extends AutoInstallationWizard {
 class AIAutoInstallCLI {
     constructor(options) {
         this.options = options;
-        this.rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            console.log('🤖 AI-Enhanced HumanBehavior SDK Auto-Installation');
-            console.log('================================================\n');
+            clack.intro('🤖 AI-Enhanced HumanBehavior SDK Auto-Installation');
             try {
                 // Get API key
                 const apiKey = yield this.getApiKey();
                 if (!apiKey) {
-                    console.error('❌ API key is required');
+                    clack.cancel('API key is required');
                     process.exit(1);
                 }
                 // Get project path
                 const projectPath = this.options.projectPath || process.cwd();
-                // Choose installation mode
-                const installationMode = yield this.chooseInstallationMode();
+                // Choose framework
+                const framework = yield this.chooseFramework();
+                if (!framework) {
+                    clack.cancel('Installation cancelled.');
+                    process.exit(0);
+                }
                 // Confirm installation
                 if (!this.options.yes) {
-                    const confirmed = yield this.confirmInstallation(projectPath, installationMode);
+                    const confirmed = yield this.confirmInstallation(projectPath, framework);
                     if (!confirmed) {
-                        console.log('Installation cancelled.');
+                        clack.cancel('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 = yield wizard.install();
-                }
-                else if (installationMode === 'manual') {
-                    // Manual AI-Enhanced framework selection
-                    const framework = yield this.chooseFramework();
-                    const wizard = new ManualFrameworkInstallationWizard(apiKey, projectPath, framework);
-                    result = yield 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 = yield wizard.install();
-                }
-                else {
-                    const wizard = new AutoInstallationWizard(apiKey, projectPath);
-                    result = yield wizard.install();
-                }
+                const spinner = clack.spinner();
+                spinner.start('🔍 Analyzing your project with AI...');
+                const wizard = new ManualFrameworkInstallationWizard(apiKey, projectPath, framework);
+                const result = yield wizard.install();
+                spinner.stop('Analysis complete!');
                 // Display results
-                this.displayResults(result, installationMode);
+                this.displayResults(result, framework);
             }
             catch (error) {
-                console.error('❌ Error:', error instanceof Error ? error.message : error);
+                clack.cancel(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
                 process.exit(1);
             }
-            finally {
-                this.rl.close();
-            }
         });
     }
     getApiKey() {
@@ -1763,262 +1827,143 @@ class AIAutoInstallCLI {
             if (this.options.apiKey) {
                 return this.options.apiKey;
             }
-            return new Promise((resolve) => {
-                this.rl.question('Enter your HumanBehavior API key: ', (answer) => {
-                    resolve(answer.trim());
-                });
-            });
-        });
-    }
-    chooseInstallationMode() {
-        return __awaiter(this, void 0, void 0, function* () {
-            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');
-                });
+            const apiKey = yield clack.text({
+                message: 'Enter your HumanBehavior API key:',
+                placeholder: 'hb_...',
+                validate: (value) => {
+                    if (!value)
+                        return 'API key is required';
+                    if (!value.startsWith('hb_'))
+                        return 'API key should start with "hb_"';
+                    return undefined;
+                }
             });
+            return apiKey;
         });
     }
-    confirmInstallation(projectPath, installationMode) {
+    confirmInstallation(projectPath, framework) {
         return __awaiter(this, void 0, void 0, function* () {
-            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');
-                });
+            const confirmed = yield clack.confirm({
+                message: `Ready to install HumanBehavior SDK in ${projectPath} for ${framework}?`
             });
+            return confirmed;
         });
     }
-    getInstallationModeDisplay(mode) {
-        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';
-    }
     chooseFramework() {
         return __awaiter(this, void 0, void 0, function* () {
-            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');
-                });
+            const framework = yield clack.select({
+                message: 'Select your framework:',
+                options: [
+                    { label: 'React', value: 'react' },
+                    { label: 'Next.js', value: 'nextjs' },
+                    { label: 'Vue', value: 'vue' },
+                    { label: 'Angular', value: 'angular' },
+                    { label: 'Svelte', value: 'svelte' },
+                    { label: 'Nuxt.js', value: 'nuxt' },
+                    { label: 'Remix', value: 'remix' },
+                    { label: 'Astro', value: 'astro' },
+                    { label: 'Gatsby', value: 'gatsby' },
+                    { label: 'Vanilla JS/TS', value: 'vanilla' }
+                ]
             });
+            return framework;
         });
     }
-    displayResults(result, installationMode) {
+    displayResults(result, framework) {
         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) => {
-                        console.log(`     • ${rec}`);
-                    });
+            clack.outro('🎉 Installation completed successfully!');
+            // Display framework info
+            clack.note(`Framework detected: ${result.framework.name} (${result.framework.type})`, 'Framework Info');
+            // Display modifications
+            if (result.modifications && result.modifications.length > 0) {
+                const modifications = result.modifications.map((mod) => `${mod.action}: ${mod.filePath} - ${mod.description}`);
+                clack.note(modifications.join('\n'), 'Files Modified');
+            }
+            // Display next steps
+            if (result.nextSteps && result.nextSteps.length > 0) {
+                clack.note(result.nextSteps.join('\n'), 'Next Steps');
+            }
+            // Display AI insights if available
+            if (result.aiAnalysis) {
+                clack.note(`Confidence: ${Math.round(result.aiAnalysis.confidence * 100)}%`, 'AI Analysis');
+                if (result.aiAnalysis.recommendations && result.aiAnalysis.recommendations.length > 0) {
+                    clack.note(result.aiAnalysis.recommendations.join('\n'), 'AI Recommendations');
                 }
             }
-            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) => {
-                console.log(`   ${mod.action === 'create' ? '➕' : '✏️'}  ${mod.description}`);
-                console.log(`      ${mod.filePath}`);
-            });
-            console.log('\n🎯 Next steps:');
-            result.nextSteps.forEach((step) => {
-                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) => {
-                console.log(`   ${error}`);
-            });
-            console.log('\n💡 Try running with --help for more options');
+            clack.cancel('Installation failed');
+            if (result.errors && result.errors.length > 0) {
+                clack.note(result.errors.join('\n'), 'Errors');
+            }
         }
     }
 }
-// CLI argument parsing
 function parseArgs() {
     const args = process.argv.slice(2);
     const options = {};
     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;
+        switch (arg) {
+            case '--help':
+            case '-h':
+                showHelp();
+                process.exit(0);
+                break;
+            case '--yes':
+            case '-y':
+                options.yes = true;
+                break;
+            case '--dry-run':
+                options.dryRun = true;
+                break;
+            case '--project':
+            case '-p':
+                options.projectPath = args[++i];
+                break;
+            case '--framework':
+            case '-f':
+                options.framework = args[++i];
+                break;
+            default:
+                if (!options.apiKey && !arg.startsWith('-')) {
+                    options.apiKey = arg;
+                }
+                break;
         }
     }
     return options;
 }
 function showHelp() {
     console.log(`
-AI-Enhanced HumanBehavior SDK Auto-Installation CLI
+🤖 HumanBehavior SDK AI Auto-Installation
 
 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
+  -h, --help              Show this help message
+  -y, --yes               Skip all prompts and use defaults
+  --dry-run               Show what would be changed without making changes
 
-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
+  -p, --project <path>    Specify project directory
+  -f, --framework <name>  Specify framework manually
 
 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
+  npx humanbehavior-js ai-auto-install
+  npx humanbehavior-js ai-auto-install hb_your_api_key_here
+  npx humanbehavior-js ai-auto-install --project ./my-app --ai
+  npx humanbehavior-js ai-auto-install --framework react --yes
 `);
 }
 // 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);
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const options = parseArgs();
+    const cli = new AIAutoInstallCLI(options);
+    cli.run().catch((error) => {
+        clack.cancel(`Unexpected error: ${error.message}`);
+        process.exit(1);
+    });
 }
-const cli = new AIAutoInstallCLI(options);
-cli.run().catch((error) => {
-    console.error('❌ Fatal error:', error);
-    process.exit(1);
-});
 
 export { AIAutoInstallCLI };
 //# sourceMappingURL=ai-auto-install.js.map