humanbehavior-js 0.4.7 → 0.4.8

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

@@ -0,0 +1,2024 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * HumanBehavior SDK Auto-Installation Wizard
+ *
+ * This wizard automatically detects the user's framework and modifies their codebase
+ * to integrate the SDK with minimal user intervention.
+ */
+class AutoInstallationWizard {
+    constructor(apiKey, projectRoot = process.cwd()) {
+        this.framework = null;
+        this.apiKey = apiKey;
+        this.projectRoot = projectRoot;
+    }
+    /**
+     * Main installation method - detects framework and auto-installs
+     */
+    install() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Step 1: Detect framework
+                this.framework = yield this.detectFramework();
+                // Step 2: Install package
+                yield this.installPackage();
+                // Step 3: Generate and apply code modifications
+                const modifications = yield this.generateModifications();
+                yield this.applyModifications(modifications);
+                // Step 4: Generate next steps
+                const nextSteps = this.generateNextSteps();
+                return {
+                    success: true,
+                    framework: this.framework,
+                    modifications,
+                    errors: [],
+                    nextSteps
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    framework: this.framework || { name: 'unknown', type: 'vanilla' },
+                    modifications: [],
+                    errors: [error instanceof Error ? error.message : 'Unknown error'],
+                    nextSteps: []
+                };
+            }
+        });
+    }
+    /**
+     * Detect the current framework and project setup
+     */
+    detectFramework() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const packageJsonPath = path.join(this.projectRoot, 'package.json');
+            if (!fs.existsSync(packageJsonPath)) {
+                return {
+                    name: 'vanilla',
+                    type: 'vanilla',
+                    projectRoot: this.projectRoot
+                };
+            }
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            const dependencies = Object.assign(Object.assign({}, packageJson.dependencies), packageJson.devDependencies);
+            // Detect framework
+            let framework = {
+                name: 'vanilla',
+                type: 'vanilla',
+                projectRoot: this.projectRoot
+            };
+            if (dependencies.nuxt) {
+                framework = {
+                    name: 'nuxt',
+                    type: 'nuxt',
+                    hasTypeScript: !!dependencies.typescript,
+                    hasRouter: true,
+                    projectRoot: this.projectRoot
+                };
+            }
+            else if (dependencies.next) {
+                framework = {
+                    name: 'nextjs',
+                    type: 'nextjs',
+                    hasTypeScript: !!dependencies.typescript || !!dependencies['@types/node'],
+                    hasRouter: true,
+                    projectRoot: this.projectRoot
+                };
+            }
+            else if (dependencies['@remix-run/react'] || dependencies['@remix-run/dev']) {
+                framework = {
+                    name: 'remix',
+                    type: 'remix',
+                    hasTypeScript: !!dependencies.typescript || !!dependencies['@types/react'],
+                    hasRouter: true,
+                    projectRoot: this.projectRoot
+                };
+            }
+            else if (dependencies.react) {
+                framework = {
+                    name: 'react',
+                    type: 'react',
+                    hasTypeScript: !!dependencies.typescript || !!dependencies['@types/react'],
+                    hasRouter: !!dependencies['react-router-dom'] || !!dependencies['react-router'],
+                    projectRoot: this.projectRoot
+                };
+            }
+            else if (dependencies.vue) {
+                framework = {
+                    name: 'vue',
+                    type: 'vue',
+                    hasTypeScript: !!dependencies.typescript || !!dependencies['@vue/cli-service'],
+                    hasRouter: !!dependencies['vue-router'],
+                    projectRoot: this.projectRoot
+                };
+            }
+            else if (dependencies['@angular/core']) {
+                framework = {
+                    name: 'angular',
+                    type: 'angular',
+                    hasTypeScript: true,
+                    hasRouter: true,
+                    projectRoot: this.projectRoot
+                };
+            }
+            else if (dependencies.svelte) {
+                framework = {
+                    name: 'svelte',
+                    type: 'svelte',
+                    hasTypeScript: !!dependencies.typescript || !!dependencies['svelte-check'],
+                    hasRouter: !!dependencies['svelte-routing'] || !!dependencies['@sveltejs/kit'],
+                    projectRoot: this.projectRoot
+                };
+            }
+            // Detect bundler
+            if (dependencies.vite) {
+                framework.bundler = 'vite';
+            }
+            else if (dependencies.webpack) {
+                framework.bundler = 'webpack';
+            }
+            else if (dependencies.esbuild) {
+                framework.bundler = 'esbuild';
+            }
+            else if (dependencies.rollup) {
+                framework.bundler = 'rollup';
+            }
+            // Detect package manager
+            if (fs.existsSync(path.join(this.projectRoot, 'yarn.lock'))) {
+                framework.packageManager = 'yarn';
+            }
+            else if (fs.existsSync(path.join(this.projectRoot, 'pnpm-lock.yaml'))) {
+                framework.packageManager = 'pnpm';
+            }
+            else {
+                framework.packageManager = 'npm';
+            }
+            return framework;
+        });
+    }
+    /**
+     * Install the SDK package
+     */
+    installPackage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { execSync } = yield import('child_process');
+            const 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';
+            try {
+                execSync(command, { cwd: this.projectRoot, stdio: 'inherit' });
+            }
+            catch (error) {
+                throw new Error(`Failed to install humanbehavior-js: ${error}`);
+            }
+        });
+    }
+    /**
+     * Generate code modifications based on framework
+     */
+    generateModifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const modifications = [];
+            switch ((_a = this.framework) === null || _a === void 0 ? void 0 : _a.type) {
+                case 'react':
+                    modifications.push(...yield this.generateReactModifications());
+                    break;
+                case 'nextjs':
+                    modifications.push(...yield this.generateNextJSModifications());
+                    break;
+                case 'nuxt':
+                    modifications.push(...yield this.generateNuxtModifications());
+                    break;
+                case 'remix':
+                    modifications.push(...yield this.generateRemixModifications());
+                    break;
+                case 'vue':
+                    modifications.push(...yield this.generateVueModifications());
+                    break;
+                case 'angular':
+                    modifications.push(...yield this.generateAngularModifications());
+                    break;
+                case 'svelte':
+                    modifications.push(...yield this.generateSvelteModifications());
+                    break;
+                default:
+                    modifications.push(...yield this.generateVanillaModifications());
+            }
+            return modifications;
+        });
+    }
+    /**
+     * Generate React-specific modifications
+     */
+    generateReactModifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modifications = [];
+            // Find main App component or index file
+            const appFile = this.findReactAppFile();
+            if (appFile) {
+                const content = fs.readFileSync(appFile, 'utf8');
+                const modifiedContent = this.injectReactProvider(content, appFile);
+                modifications.push({
+                    filePath: appFile,
+                    action: 'modify',
+                    content: modifiedContent,
+                    description: 'Added HumanBehaviorProvider to React app'
+                });
+            }
+            // Create or append to environment file
+            modifications.push(this.createEnvironmentModification(this.framework));
+            return modifications;
+        });
+    }
+    /**
+     * Generate Next.js-specific modifications
+     */
+    generateNextJSModifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modifications = [];
+            // Check for App Router
+            const appLayoutFile = path.join(this.projectRoot, 'src', 'app', 'layout.tsx');
+            const pagesLayoutFile = path.join(this.projectRoot, 'src', 'pages', '_app.tsx');
+            if (fs.existsSync(appLayoutFile)) {
+                // Create providers.tsx file for App Router
+                modifications.push({
+                    filePath: path.join(this.projectRoot, 'src', 'app', 'providers.tsx'),
+                    action: 'create',
+                    content: `'use client';
+
+import { HumanBehaviorProvider } from 'humanbehavior-js/react';
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <HumanBehaviorProvider apiKey={process.env.NEXT_PUBLIC_HUMANBEHAVIOR_API_KEY}>
+      {children}
+    </HumanBehaviorProvider>
+  );
+}`,
+                    description: 'Created providers.tsx file for Next.js App Router'
+                });
+                // Modify layout.tsx to use the provider
+                const content = fs.readFileSync(appLayoutFile, 'utf8');
+                const modifiedContent = this.injectNextJSAppRouter(content);
+                modifications.push({
+                    filePath: appLayoutFile,
+                    action: 'modify',
+                    content: modifiedContent,
+                    description: 'Added Providers wrapper to Next.js App Router layout'
+                });
+            }
+            else if (fs.existsSync(pagesLayoutFile)) {
+                // Create providers.tsx file for Pages Router
+                modifications.push({
+                    filePath: path.join(this.projectRoot, 'src', 'components', 'providers.tsx'),
+                    action: 'create',
+                    content: `'use client';
+
+import { HumanBehaviorProvider } from 'humanbehavior-js/react';
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <HumanBehaviorProvider apiKey={process.env.NEXT_PUBLIC_HUMANBEHAVIOR_API_KEY}>
+      {children}
+    </HumanBehaviorProvider>
+  );
+}`,
+                    description: 'Created providers.tsx file for Pages Router'
+                });
+                // Modify _app.tsx to use the provider
+                const content = fs.readFileSync(pagesLayoutFile, 'utf8');
+                const modifiedContent = this.injectNextJSPagesRouter(content);
+                modifications.push({
+                    filePath: pagesLayoutFile,
+                    action: 'modify',
+                    content: modifiedContent,
+                    description: 'Added Providers wrapper to Next.js Pages Router'
+                });
+            }
+            // Create or append to environment file
+            modifications.push(this.createEnvironmentModification(this.framework));
+            return modifications;
+        });
+    }
+    /**
+     * Generate Nuxt-specific modifications
+     */
+    generateNuxtModifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modifications = [];
+            // Create plugin file for Nuxt (in app directory)
+            const pluginFile = path.join(this.projectRoot, 'app', 'plugins', 'humanbehavior.client.ts');
+            modifications.push({
+                filePath: pluginFile,
+                action: 'create',
+                content: `import { HumanBehaviorTracker } from 'humanbehavior-js';
+
+export default defineNuxtPlugin(() => {
+  const config = useRuntimeConfig();
+  
+  // Initialize HumanBehavior SDK (client-side only)
+  if (typeof window !== 'undefined') {
+    const apiKey = config.public.humanBehaviorApiKey;
+    console.log('HumanBehavior: API key:', apiKey ? 'present' : 'missing');
+    
+    if (apiKey) {
+      try {
+        const tracker = HumanBehaviorTracker.init(apiKey);
+        console.log('HumanBehavior: Tracker initialized successfully');
+      } catch (error) {
+        console.error('HumanBehavior: Failed to initialize tracker:', error);
+      }
+    } else {
+      console.error('HumanBehavior: No API key found in runtime config');
+    }
+  }
+});`,
+                description: 'Created Nuxt plugin for HumanBehavior SDK in app directory'
+            });
+            // Create environment configuration
+            const nuxtConfigFile = path.join(this.projectRoot, 'nuxt.config.ts');
+            if (fs.existsSync(nuxtConfigFile)) {
+                const content = fs.readFileSync(nuxtConfigFile, 'utf8');
+                const modifiedContent = this.injectNuxtConfig(content);
+                modifications.push({
+                    filePath: nuxtConfigFile,
+                    action: 'modify',
+                    content: modifiedContent,
+                    description: 'Added HumanBehavior runtime config to Nuxt config'
+                });
+            }
+            // Create or append to environment file
+            modifications.push(this.createEnvironmentModification(this.framework));
+            return modifications;
+        });
+    }
+    /**
+     * Generate Remix-specific modifications
+     */
+    generateRemixModifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modifications = [];
+            // Find root.tsx file
+            const rootFile = path.join(this.projectRoot, 'app', 'root.tsx');
+            if (fs.existsSync(rootFile)) {
+                const content = fs.readFileSync(rootFile, 'utf8');
+                const modifiedContent = this.injectRemixProvider(content);
+                modifications.push({
+                    filePath: rootFile,
+                    action: 'modify',
+                    content: modifiedContent,
+                    description: 'Added HumanBehaviorProvider to Remix root component'
+                });
+            }
+            // Create or append to environment file
+            modifications.push(this.createEnvironmentModification(this.framework));
+            return modifications;
+        });
+    }
+    /**
+     * Generate Vue-specific modifications
+     */
+    generateVueModifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modifications = [];
+            // Find main.js or main.ts
+            const mainFile = this.findVueMainFile();
+            if (mainFile) {
+                const content = fs.readFileSync(mainFile, 'utf8');
+                const modifiedContent = this.injectVuePlugin(content);
+                modifications.push({
+                    filePath: mainFile,
+                    action: 'modify',
+                    content: modifiedContent,
+                    description: 'Added HumanBehaviorPlugin to Vue app'
+                });
+            }
+            // Create or append to environment file
+            modifications.push(this.createEnvironmentModification(this.framework));
+            return modifications;
+        });
+    }
+    /**
+     * Generate Angular-specific modifications
+     */
+    generateAngularModifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modifications = [];
+            // Check for modern Angular (standalone components) vs legacy (NgModule)
+            const appModuleFile = path.join(this.projectRoot, 'src', 'app', 'app.module.ts');
+            const appComponentFile = path.join(this.projectRoot, 'src', 'app', 'app.ts');
+            const mainFile = path.join(this.projectRoot, 'src', 'main.ts');
+            const isModernAngular = fs.existsSync(appComponentFile) && !fs.existsSync(appModuleFile);
+            if (isModernAngular) {
+                // Modern Angular 17+ with standalone components
+                if (fs.existsSync(mainFile)) {
+                    const content = fs.readFileSync(mainFile, 'utf8');
+                    const modifiedContent = this.injectAngularStandaloneInit(content);
+                    modifications.push({
+                        filePath: mainFile,
+                        action: 'modify',
+                        content: modifiedContent,
+                        description: 'Added HumanBehavior initialization to Angular main.ts'
+                    });
+                }
+            }
+            else if (fs.existsSync(appModuleFile)) {
+                // Legacy Angular with NgModule
+                const content = fs.readFileSync(appModuleFile, 'utf8');
+                const modifiedContent = this.injectAngularModule(content);
+                modifications.push({
+                    filePath: appModuleFile,
+                    action: 'modify',
+                    content: modifiedContent,
+                    description: 'Added HumanBehaviorModule to Angular app'
+                });
+            }
+            // Handle Angular environment file (legacy structure)
+            const envFile = path.join(this.projectRoot, 'src', 'environments', 'environment.ts');
+            if (fs.existsSync(envFile)) {
+                const content = fs.readFileSync(envFile, 'utf8');
+                if (!content.includes('humanBehaviorApiKey')) {
+                    const modifiedContent = content.replace(/export const environment = {([\s\S]*?)};/, `export const environment = {
+  $1,
+  humanBehaviorApiKey: process.env['HUMANBEHAVIOR_API_KEY'] || ''
+};`);
+                    modifications.push({
+                        filePath: envFile,
+                        action: 'modify',
+                        content: modifiedContent,
+                        description: 'Added API key to Angular environment'
+                    });
+                }
+            }
+            // Create or append to environment file
+            modifications.push(this.createEnvironmentModification(this.framework));
+            return modifications;
+        });
+    }
+    /**
+     * Generate Svelte-specific modifications
+     */
+    generateSvelteModifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modifications = [];
+            // Check for SvelteKit
+            const svelteConfigFile = path.join(this.projectRoot, 'svelte.config.js');
+            const isSvelteKit = fs.existsSync(svelteConfigFile);
+            if (isSvelteKit) {
+                // SvelteKit - create layout file
+                const layoutFile = path.join(this.projectRoot, 'src', 'routes', '+layout.svelte');
+                if (fs.existsSync(layoutFile)) {
+                    const content = fs.readFileSync(layoutFile, 'utf8');
+                    const modifiedContent = this.injectSvelteKitLayout(content);
+                    modifications.push({
+                        filePath: layoutFile,
+                        action: 'modify',
+                        content: modifiedContent,
+                        description: 'Added HumanBehavior store to SvelteKit layout'
+                    });
+                }
+            }
+            else {
+                // Regular Svelte - modify main file
+                const mainFile = this.findSvelteMainFile();
+                if (mainFile) {
+                    const content = fs.readFileSync(mainFile, 'utf8');
+                    const modifiedContent = this.injectSvelteStore(content);
+                    modifications.push({
+                        filePath: mainFile,
+                        action: 'modify',
+                        content: modifiedContent,
+                        description: 'Added HumanBehavior store to Svelte app'
+                    });
+                }
+            }
+            // Create or append to environment file
+            modifications.push(this.createEnvironmentModification(this.framework));
+            return modifications;
+        });
+    }
+    /**
+     * Generate vanilla JS/TS modifications
+     */
+    generateVanillaModifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modifications = [];
+            // Find HTML file to inject script
+            const htmlFile = this.findHTMLFile();
+            if (htmlFile) {
+                const content = fs.readFileSync(htmlFile, 'utf8');
+                const modifiedContent = this.injectVanillaScript(content);
+                modifications.push({
+                    filePath: htmlFile,
+                    action: 'modify',
+                    content: modifiedContent,
+                    description: 'Added HumanBehavior CDN script to HTML file'
+                });
+            }
+            // Create or append to environment file
+            modifications.push(this.createEnvironmentModification(this.framework));
+            return modifications;
+        });
+    }
+    /**
+     * Apply modifications to the codebase
+     */
+    applyModifications(modifications) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const modification of modifications) {
+                try {
+                    const dir = path.dirname(modification.filePath);
+                    if (!fs.existsSync(dir)) {
+                        fs.mkdirSync(dir, { recursive: true });
+                    }
+                    switch (modification.action) {
+                        case 'create':
+                            fs.writeFileSync(modification.filePath, modification.content);
+                            break;
+                        case 'modify':
+                            fs.writeFileSync(modification.filePath, modification.content);
+                            break;
+                        case 'append':
+                            fs.appendFileSync(modification.filePath, '\n' + modification.content);
+                            break;
+                    }
+                }
+                catch (error) {
+                    throw new Error(`Failed to apply modification to ${modification.filePath}: ${error}`);
+                }
+            }
+        });
+    }
+    /**
+     * Generate next steps for the user
+     */
+    generateNextSteps() {
+        var _a, _b;
+        const steps = [
+            '✅ SDK installed and configured automatically!',
+            '🚀 Your app is now tracking user behavior',
+            '📊 View sessions in your HumanBehavior dashboard',
+            '🔧 Customize tracking in your code as needed'
+        ];
+        if (((_a = this.framework) === null || _a === void 0 ? void 0 : _a.type) === 'react' || ((_b = this.framework) === null || _b === void 0 ? void 0 : _b.type) === 'nextjs') {
+            steps.push('💡 Use the useHumanBehavior() hook to track custom events');
+        }
+        return steps;
+    }
+    // Helper methods for file detection and content injection
+    findReactAppFile() {
+        const possibleFiles = [
+            'src/App.jsx', 'src/App.js', 'src/App.tsx', 'src/App.ts',
+            'src/index.js', 'src/index.tsx', 'src/main.js', 'src/main.tsx'
+        ];
+        for (const file of possibleFiles) {
+            const fullPath = path.join(this.projectRoot, file);
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        return null;
+    }
+    findVueMainFile() {
+        const possibleFiles = [
+            'src/main.js', 'src/main.ts', 'src/main.jsx', 'src/main.tsx'
+        ];
+        for (const file of possibleFiles) {
+            const fullPath = path.join(this.projectRoot, file);
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        return null;
+    }
+    findSvelteMainFile() {
+        const possibleFiles = [
+            'src/main.js', 'src/main.ts', 'src/main.svelte'
+        ];
+        for (const file of possibleFiles) {
+            const fullPath = path.join(this.projectRoot, file);
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        return null;
+    }
+    findHTMLFile() {
+        const possibleFiles = ['index.html', 'public/index.html', 'dist/index.html'];
+        for (const file of possibleFiles) {
+            const fullPath = path.join(this.projectRoot, file);
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        return null;
+    }
+    injectReactProvider(content, filePath) {
+        var _a;
+        filePath.endsWith('.tsx') || filePath.endsWith('.ts');
+        // Check if already has HumanBehaviorProvider
+        if (content.includes('HumanBehaviorProvider')) {
+            return content;
+        }
+        // Determine the correct environment variable syntax based on bundler
+        const isVite = ((_a = this.framework) === null || _a === void 0 ? void 0 : _a.bundler) === 'vite';
+        const envVar = isVite
+            ? '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
+        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 (
+    <HumanBehaviorProvider apiKey={${envVar}}>
+      $1
+    </HumanBehaviorProvider>
+  );`);
+        }
+        return `${importStatement}\n\n${content}`;
+    }
+    injectNextJSAppRouter(content) {
+        if (content.includes('Providers')) {
+            return content;
+        }
+        const importStatement = `import { Providers } from './providers';`;
+        // First, add the import statement
+        let modifiedContent = content.replace(/export default function RootLayout/, `${importStatement}\n\nexport default function RootLayout`);
+        // Then wrap the body content with Providers
+        // Use a more specific approach to handle the body content
+        modifiedContent = modifiedContent.replace(/<body([^>]*)>([\s\S]*?)<\/body>/, (match, bodyAttrs, bodyContent) => {
+            // Trim whitespace and newlines from bodyContent
+            const trimmedContent = bodyContent.trim();
+            return `<body${bodyAttrs}>
+        <Providers>
+          ${trimmedContent}
+        </Providers>
+      </body>`;
+        });
+        return modifiedContent;
+    }
+    injectNextJSPagesRouter(content) {
+        if (content.includes('Providers')) {
+            return content;
+        }
+        const importStatement = `import { Providers } from '../components/providers';`;
+        return content.replace(/function MyApp/, `${importStatement}\n\nfunction MyApp`).replace(/return \(([\s\S]*?)\);/, `return (
+    <Providers>
+      $1
+    </Providers>
+  );`);
+    }
+    injectRemixProvider(content) {
+        if (content.includes('HumanBehaviorProvider')) {
+            return content;
+        }
+        const importStatement = `import { HumanBehaviorProvider, createHumanBehaviorLoader } from 'humanbehavior-js/remix';`;
+        const useLoaderDataImport = `import { useLoaderData } from "@remix-run/react";`;
+        // Add imports more robustly
+        let modifiedContent = content;
+        // Add HumanBehaviorProvider import - find the last import and add after it
+        if (!content.includes('HumanBehaviorProvider')) {
+            const lastImportIndex = modifiedContent.lastIndexOf('import');
+            if (lastImportIndex !== -1) {
+                const nextLineIndex = modifiedContent.indexOf('\n', lastImportIndex);
+                if (nextLineIndex !== -1) {
+                    modifiedContent = modifiedContent.slice(0, nextLineIndex + 1) +
+                        importStatement + '\n' +
+                        modifiedContent.slice(nextLineIndex + 1);
+                }
+                else {
+                    modifiedContent = modifiedContent + '\n' + importStatement;
+                }
+            }
+            else {
+                modifiedContent = importStatement + '\n' + modifiedContent;
+            }
+        }
+        // Add useLoaderData import - find the last import and add after it
+        if (!content.includes('useLoaderData')) {
+            const lastImportIndex = modifiedContent.lastIndexOf('import');
+            if (lastImportIndex !== -1) {
+                const nextLineIndex = modifiedContent.indexOf('\n', lastImportIndex);
+                if (nextLineIndex !== -1) {
+                    modifiedContent = modifiedContent.slice(0, nextLineIndex + 1) +
+                        useLoaderDataImport + '\n' +
+                        modifiedContent.slice(nextLineIndex + 1);
+                }
+                else {
+                    modifiedContent = modifiedContent + '\n' + useLoaderDataImport;
+                }
+            }
+            else {
+                modifiedContent = useLoaderDataImport + '\n' + modifiedContent;
+            }
+        }
+        // Add loader function before the App component
+        if (!content.includes('export const loader')) {
+            modifiedContent = modifiedContent.replace(/export default function App\(\)/, `export const loader = createHumanBehaviorLoader();
+
+export default function App()`);
+        }
+        // Wrap the App component content with HumanBehaviorProvider
+        modifiedContent = modifiedContent.replace(/export default function App\(\) \{[\s\S]*?return \(([\s\S]*?)\);[\s\S]*?\}/, `export default function App() {
+  const data = useLoaderData<typeof loader>();
+  
+  return (
+    <HumanBehaviorProvider apiKey={data.ENV.HUMANBEHAVIOR_API_KEY}>
+      $1
+    </HumanBehaviorProvider>
+  );
+}`);
+        return modifiedContent;
+    }
+    injectVuePlugin(content) {
+        if (content.includes('HumanBehaviorPlugin')) {
+            return content;
+        }
+        const importStatement = `import { HumanBehaviorPlugin } from 'humanbehavior-js/vue';`;
+        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(`);
+        }
+        else {
+            // Vue 2
+            return content.replace(/import.*from.*['"]vue['"]/, `$&\n${importStatement}`).replace(/new Vue\(/, `${pluginUsage}\n\nnew Vue(`);
+        }
+    }
+    injectAngularModule(content) {
+        if (content.includes('HumanBehaviorModule')) {
+            return content;
+        }
+        const importStatement = `import { HumanBehaviorModule } from 'humanbehavior-js/angular';`;
+        const environmentImport = `import { environment } from '../environments/environment';`;
+        // Add environment import if not present
+        let modifiedContent = content;
+        if (!content.includes('environment')) {
+            modifiedContent = content.replace(/import.*from.*['"]@angular/, `${environmentImport}\n$&`);
+        }
+        return modifiedContent.replace(/imports:\s*\[([\s\S]*?)\]/, `imports: [
+    $1,
+    HumanBehaviorModule.forRoot({
+      apiKey: environment.humanBehaviorApiKey
+    })
+  ]`).replace(/import.*from.*['"]@angular/, `$&\n${importStatement}`);
+    }
+    injectAngularStandaloneInit(content) {
+        if (content.includes('initializeHumanBehavior')) {
+            return content;
+        }
+        const importStatement = `import { initializeHumanBehavior } from 'humanbehavior-js/angular';`;
+        // Add import at the top
+        let modifiedContent = content.replace(/import.*from.*['"]@angular/, `${importStatement}\n$&`);
+        // Add initialization after bootstrapApplication
+        modifiedContent = modifiedContent.replace(/(bootstrapApplication\([^}]+\}?\)(?:\s*\.catch[^;]+;)?)/, `$1
+
+// Initialize HumanBehavior SDK (client-side only)
+if (typeof window !== 'undefined') {
+  const tracker = initializeHumanBehavior(
+    '${this.apiKey}'
+  );
+}`);
+        return modifiedContent;
+    }
+    injectSvelteStore(content) {
+        if (content.includes('humanBehaviorStore')) {
+            return content;
+        }
+        const importStatement = `import { humanBehaviorStore } from 'humanbehavior-js/svelte';`;
+        const initCode = `humanBehaviorStore.init(process.env.PUBLIC_HUMANBEHAVIOR_API_KEY || '');`;
+        return `${importStatement}\n${initCode}\n\n${content}`;
+    }
+    injectSvelteKitLayout(content) {
+        if (content.includes('humanBehaviorStore')) {
+            return content;
+        }
+        const importStatement = `import { humanBehaviorStore } from 'humanbehavior-js/svelte';`;
+        const envImport = `import { PUBLIC_HUMANBEHAVIOR_API_KEY } from '$env/static/public';`;
+        const initCode = `humanBehaviorStore.init(PUBLIC_HUMANBEHAVIOR_API_KEY || '');`;
+        // Add to script section - handle different script tag patterns
+        if (content.includes('<script lang="ts">')) {
+            return content.replace(/<script lang="ts">/, `<script lang="ts">\n\t${envImport}\n\t${importStatement}\n\t${initCode}`);
+        }
+        else if (content.includes('<script>')) {
+            return content.replace(/<script>/, `<script>\n\t${envImport}\n\t${importStatement}\n\t${initCode}`);
+        }
+        else if (content.includes('<script context="module">')) {
+            return content.replace(/<script\s+context="module">/, `<script context="module">\n\t${envImport}\n\t${importStatement}\n\t${initCode}`);
+        }
+        else {
+            // If no script tag found, add one at the beginning
+            return content.replace(/<svelte:head>/, `<script lang="ts">\n\t${envImport}\n\t${importStatement}\n\t${initCode}\n</script>\n\n<svelte:head>`);
+        }
+    }
+    injectVanillaScript(content) {
+        if (content.includes('humanbehavior-js')) {
+            return content;
+        }
+        const cdnScript = `<script src="https://unpkg.com/humanbehavior-js@latest/dist/index.min.js"></script>`;
+        const initScript = `<script>
+  // Initialize HumanBehavior SDK
+  // Note: For vanilla HTML, the API key must be hardcoded since env vars aren't available
+  const tracker = HumanBehaviorTracker.init('${this.apiKey}');
+</script>`;
+        return content.replace(/<\/head>/, `  ${cdnScript}\n  ${initScript}\n</head>`);
+    }
+    injectNuxtConfig(content) {
+        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({
+  runtimeConfig: {
+    public: {
+      humanBehaviorApiKey: process.env.NUXT_PUBLIC_HUMANBEHAVIOR_API_KEY
+    }
+  },`);
+    }
+    /**
+     * Helper method to find the best environment file for a framework
+     */
+    findBestEnvFile(framework) {
+        const possibleEnvFiles = [
+            '.env.local',
+            '.env.development.local',
+            '.env.development',
+            '.env.local.development',
+            '.env',
+            '.env.production',
+            '.env.staging'
+        ];
+        // Framework-specific environment variable names
+        const getEnvVarName = (framework) => {
+            // Handle React+Vite specifically
+            if (framework.type === 'react' && framework.bundler === 'vite') {
+                return 'VITE_HUMANBEHAVIOR_API_KEY';
+            }
+            // Framework-specific mappings
+            const envVarNames = {
+                react: 'HUMANBEHAVIOR_API_KEY',
+                nextjs: 'NEXT_PUBLIC_HUMANBEHAVIOR_API_KEY',
+                vue: 'VITE_HUMANBEHAVIOR_API_KEY',
+                svelte: 'PUBLIC_HUMANBEHAVIOR_API_KEY',
+                angular: 'HUMANBEHAVIOR_API_KEY',
+                nuxt: 'NUXT_PUBLIC_HUMANBEHAVIOR_API_KEY',
+                remix: 'HUMANBEHAVIOR_API_KEY',
+                vanilla: 'HUMANBEHAVIOR_API_KEY',
+                node: 'HUMANBEHAVIOR_API_KEY',
+                auto: 'HUMANBEHAVIOR_API_KEY'
+            };
+            return envVarNames[framework.type] || 'HUMANBEHAVIOR_API_KEY';
+        };
+        const envVarName = getEnvVarName(framework);
+        // Check for existing files
+        for (const envFile of possibleEnvFiles) {
+            const fullPath = path.join(this.projectRoot, envFile);
+            if (fs.existsSync(fullPath)) {
+                return { filePath: fullPath, envVarName };
+            }
+        }
+        // Framework-specific default file creation
+        const defaultFiles = {
+            react: '.env.local',
+            nextjs: '.env.local',
+            vue: '.env.local',
+            svelte: '.env',
+            angular: '.env',
+            nuxt: '.env',
+            remix: '.env.local',
+            vanilla: '.env',
+            node: '.env',
+            auto: '.env'
+        };
+        const defaultFile = defaultFiles[framework.type] || '.env';
+        return {
+            filePath: path.join(this.projectRoot, defaultFile),
+            envVarName
+        };
+    }
+    /**
+     * Helper method to create or append to environment files
+     */
+    createEnvironmentModification(framework) {
+        const { filePath, envVarName } = this.findBestEnvFile(framework);
+        if (fs.existsSync(filePath)) {
+            // Check if the variable already exists
+            const content = fs.readFileSync(filePath, 'utf8');
+            if (content.includes(envVarName)) {
+                // Variable exists, don't modify
+                return {
+                    filePath,
+                    action: 'modify',
+                    content: content, // No change
+                    description: `API key already exists in ${path.basename(filePath)}`
+                };
+            }
+            else {
+                // Append to existing file
+                return {
+                    filePath,
+                    action: 'append',
+                    content: `\n${envVarName}=${this.apiKey}`,
+                    description: `Added API key to existing ${path.basename(filePath)}`
+                };
+            }
+        }
+        else {
+            // Create new file
+            return {
+                filePath,
+                action: 'create',
+                content: `${envVarName}=${this.apiKey}`,
+                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
+ *
+ * This connects to your deployed Lambda function via API Gateway
+ */
+class RemoteAIService {
+    constructor(config) {
+        this.config = Object.assign({ timeout: 10000 }, config);
+    }
+    /**
+     * Analyze code patterns using your deployed AI service
+     */
+    analyzeCodePatterns(codeSamples) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch(`${this.config.apiEndpoint}/analyze`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ codeSamples }),
+                    signal: AbortSignal.timeout(this.config.timeout || 10000)
+                });
+                if (!response.ok) {
+                    throw new Error(`AI service returned ${response.status}: ${response.statusText}`);
+                }
+                const result = yield response.json();
+                return result.analysis;
+            }
+            catch (error) {
+                console.warn('Remote AI service failed, falling back to heuristic analysis:', error);
+                return this.performHeuristicAnalysis(codeSamples);
+            }
+        });
+    }
+    /**
+     * Resolve conflicts using your deployed AI service
+     */
+    resolveConflicts(conflicts, framework) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch(`${this.config.apiEndpoint}/resolve-conflicts`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ conflicts, framework }),
+                    signal: AbortSignal.timeout(this.config.timeout || 10000)
+                });
+                if (!response.ok) {
+                    throw new Error(`AI service returned ${response.status}: ${response.statusText}`);
+                }
+                const result = yield response.json();
+                return result.resolutions || [];
+            }
+            catch (error) {
+                console.warn('Remote AI conflict resolution failed, using heuristic approach:', error);
+                return this.resolveConflictsHeuristic(conflicts, framework);
+            }
+        });
+    }
+    /**
+     * Generate optimizations using your deployed AI service
+     */
+    generateOptimizations(framework, patterns) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch(`${this.config.apiEndpoint}/optimize`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ framework, patterns }),
+                    signal: AbortSignal.timeout(this.config.timeout || 10000)
+                });
+                if (!response.ok) {
+                    throw new Error(`AI service returned ${response.status}: ${response.statusText}`);
+                }
+                const result = yield response.json();
+                return result.optimizations || [];
+            }
+            catch (error) {
+                console.warn('Remote AI optimization generation failed, using heuristic approach:', error);
+                return this.generateOptimizationsHeuristic(framework, patterns);
+            }
+        });
+    }
+    /**
+     * Heuristic analysis fallback
+     */
+    performHeuristicAnalysis(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
+        };
+    }
+    /**
+     * Heuristic conflict resolution
+     */
+    resolveConflictsHeuristic(conflicts, framework) {
+        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;
+    }
+    /**
+     * Heuristic optimization generation
+     */
+    generateOptimizationsHeuristic(framework, patterns) {
+        const 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;
+    }
+}
+
+/**
+ * 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.
+ */
+class ManualFrameworkInstallationWizard extends AutoInstallationWizard {
+    constructor(apiKey, projectRoot = process.cwd(), framework) {
+        super(apiKey, projectRoot);
+        this.selectedFramework = framework.toLowerCase();
+        this.framework = this.createFrameworkInfo(this.selectedFramework);
+    }
+    /**
+     * Manual installation with user-specified framework
+     */
+    install() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Step 1: Handle framework selection
+                if (this.selectedFramework === 'auto') {
+                    // Use full AI detection for "Other" option
+                    this.framework = yield 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 = yield this.runFullDetection();
+                    // Step 3: Merge manual framework with detected details
+                    this.framework = Object.assign(Object.assign({}, detectedFramework), { name: this.framework.name, type: this.framework.type });
+                }
+                // Step 4: Install package
+                yield this.installPackage();
+                // Step 5: Generate and apply code modifications
+                const modifications = yield this.generateModifications();
+                yield 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.
+     */
+    runFullDetection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield this.scanProjectFiles();
+                const codeSamples = yield this.extractCodeSamples(projectFiles);
+                const aiAnalysis = yield aiService.analyzeCodePatterns(codeSamples);
+                return aiAnalysis.framework;
+            }
+            else {
+                // Use traditional detection for manual frameworks
+                const tempWizard = new AutoInstallationWizard(this.apiKey, this.projectRoot);
+                const detected = yield tempWizard.detectFramework();
+                return detected;
+            }
+        });
+    }
+    /**
+     * Scan project files for analysis
+     */
+    scanProjectFiles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const files = [];
+            const scanDir = (dir, depth = 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
+     */
+    isRelevantFile(filename) {
+        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
+     */
+    extractCodeSamples(files) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const samples = [];
+            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
+     */
+    createFrameworkInfo(framework) {
+        const frameworkMap = {
+            '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
+     */
+    detectFramework() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.framework || { name: 'unknown', type: 'vanilla' };
+        });
+    }
+    /**
+     * Generate next steps with manual mode info
+     */
+    generateManualNextSteps() {
+        var _a;
+        return [
+            '✅ Manual framework installation completed!',
+            `🎯 Selected framework: ${((_a = this.framework) === null || _a === void 0 ? void 0 : _a.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
+     */
+    getIntegrationStrategy() {
+        var _a;
+        if (!((_a = this.framework) === null || _a === void 0 ? void 0 : _a.type))
+            return 'script';
+        switch (this.framework.type) {
+            case 'react':
+            case 'nextjs':
+                return 'provider';
+            case 'vue':
+                return 'plugin';
+            case 'angular':
+                return 'module';
+            default:
+                return 'script';
+        }
+    }
+}
+
+/**
+ * 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.
+ */
+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');
+            try {
+                // Get API key
+                const apiKey = yield 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 = yield this.chooseInstallationMode();
+                // Confirm installation
+                if (!this.options.yes) {
+                    const confirmed = yield 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 = 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();
+                }
+                // Display results
+                this.displayResults(result, installationMode);
+            }
+            catch (error) {
+                console.error('❌ Error:', error instanceof Error ? error.message : error);
+                process.exit(1);
+            }
+            finally {
+                this.rl.close();
+            }
+        });
+    }
+    getApiKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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');
+                });
+            });
+        });
+    }
+    confirmInstallation(projectPath, installationMode) {
+        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');
+                });
+            });
+        });
+    }
+    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');
+                });
+            });
+        });
+    }
+    displayResults(result, installationMode) {
+        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}`);
+                    });
+                }
+            }
+            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');
+        }
+    }
+}
+// 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;
+        }
+    }
+    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 };
+//# sourceMappingURL=ai-auto-install.js.map