humanbehavior-js 0.4.28 → 0.5.0

package/src/wizard/index.ts

@@ -1,23 +0,0 @@
-/**
- * HumanBehavior SDK Wizard Module
- * 
- * This module provides AI-enhanced auto-installation capabilities for the HumanBehavior SDK.
- * It includes traditional installation, AI-powered analysis, and centralized AI services.
- */
-
-// Core wizard components
-export { AutoInstallationWizard, FrameworkInfo, CodeModification, InstallationResult } from './core/install-wizard';
-
-// AI-enhanced wizard components
-export { AIEnhancedInstallationWizard, AIBrowserInstallationWizard, AICodeAnalysis, AIInstallationResult } from './ai/ai-install-wizard';
-
-// CLI components
-export { AIAutoInstallCLI } from './cli/ai-auto-install';
-export { AutoInstallCLI } from './cli/auto-install';
-
-// AI services
-export { RemoteAIService, RemoteAIServiceConfig } from './services/remote-ai-service';
-export { CentralizedAIService, CentralizedAIServiceConfig } from './services/centralized-ai-service';
-
-// Re-export main wizard for backward compatibility
-export { AutoInstallationWizard as InstallWizard } from './core/install-wizard'; 

package/src/wizard/services/centralized-ai-service.ts

@@ -1,668 +0,0 @@
-/**
- * Centralized AI Service Implementation
- * 
- * This service runs on your backend infrastructure and provides AI-powered
- * code analysis without requiring users to provide their own API keys.
- * 
- * The service can be deployed as:
- * - AWS Lambda function
- * - Docker container
- * - Express.js server
- * - Cloud function
- */
-
-import { AICodeAnalysis } from '../ai/ai-install-wizard';
-
-export interface FrameworkInfo {
-  name: string;
-  type: 'react' | 'vue' | 'angular' | 'svelte' | 'nextjs' | 'nuxt' | 'remix' | 'vanilla' | 'astro' | 'node';
-  bundler?: 'vite' | 'webpack' | 'esbuild' | 'rollup';
-  packageManager?: 'npm' | 'yarn' | 'pnpm';
-  hasTypeScript?: boolean;
-  hasRouter?: boolean;
-  projectRoot?: string;
-}
-
-export interface CentralizedAIServiceConfig {
-  openaiApiKey: string;
-  openaiModel?: string;
-  maxTokens?: number;
-  temperature?: number;
-  enableCaching?: boolean;
-  cacheTTL?: number;
-}
-
-export interface AIAnalysisRequest {
-  codeSamples: string[];
-  projectType?: string;
-  userAgent?: string;
-  timestamp: string;
-}
-
-export interface AIAnalysisResponse {
-  analysis: AICodeAnalysis;
-  processingTime: number;
-  cacheHit?: boolean;
-  modelUsed: string;
-}
-
-export interface ConflictResolutionRequest {
-  conflicts: string[];
-  framework: FrameworkInfo;
-  codeContext?: string;
-}
-
-export interface OptimizationRequest {
-  framework: FrameworkInfo;
-  patterns: string[];
-  projectContext?: string;
-}
-
-/**
- * Centralized AI Service Implementation
- * This runs on your backend infrastructure
- */
-export class CentralizedAIService {
-  private config: CentralizedAIServiceConfig;
-  private cache: Map<string, any> = new Map();
-  private openai: any; // OpenAI client
-
-  constructor(config: CentralizedAIServiceConfig) {
-    this.config = {
-      openaiModel: 'gpt-4',
-      maxTokens: 2000,
-      temperature: 0.3,
-      enableCaching: true,
-      cacheTTL: 3600, // 1 hour
-      ...config
-    };
-    
-    this.initializeOpenAI();
-  }
-
-  /**
-   * Initialize OpenAI client
-   */
-  private initializeOpenAI() {
-    try {
-      // Import OpenAI dynamically to avoid bundling issues
-      const { OpenAI } = require('openai');
-      this.openai = new OpenAI({
-        apiKey: this.config.openaiApiKey
-      });
-    } catch (error) {
-      console.warn('OpenAI not available, falling back to heuristic analysis');
-      this.openai = null;
-    }
-  }
-
-  /**
-   * Analyze code patterns using AI
-   */
-  async analyzeCodePatterns(codeSamples: string[]): Promise<AICodeAnalysis> {
-    const request: AIAnalysisRequest = {
-      codeSamples,
-      timestamp: new Date().toISOString()
-    };
-
-    // Check cache first
-    const cacheKey = this.generateCacheKey(request);
-    if (this.config.enableCaching) {
-      const cached = this.cache.get(cacheKey);
-      if (cached && this.isCacheValid(cached.timestamp)) {
-        return cached.analysis;
-      }
-    }
-
-    // Perform AI analysis
-    const startTime = Date.now();
-    const analysis = await this.performAIAnalysis(request);
-    const processingTime = Date.now() - startTime;
-
-    // Cache the result
-    if (this.config.enableCaching) {
-      this.cache.set(cacheKey, {
-        analysis,
-        timestamp: Date.now()
-      });
-    }
-
-    return analysis;
-  }
-
-  /**
-   * Resolve conflicts using AI
-   */
-  async resolveConflicts(conflicts: string[], framework: FrameworkInfo): Promise<string[]> {
-    const request: ConflictResolutionRequest = {
-      conflicts,
-      framework,
-      codeContext: 'HumanBehavior SDK integration'
-    };
-
-    if (!this.openai) {
-      return this.resolveConflictsHeuristic(conflicts, framework);
-    }
-
-    try {
-      const prompt = this.buildConflictResolutionPrompt(request);
-      const response = await this.openai.chat.completions.create({
-        model: this.config.openaiModel,
-        messages: [
-          {
-            role: 'system',
-            content: 'You are an expert at resolving code integration conflicts. Provide specific resolution strategies.'
-          },
-          {
-            role: 'user',
-            content: prompt
-          }
-        ],
-        max_tokens: this.config.maxTokens,
-        temperature: this.config.temperature
-      });
-
-      const content = response.choices[0]?.message?.content;
-      if (content && typeof content === 'string') {
-        return this.parseConflictResolutions(content);
-      }
-      return [];
-    } catch (error) {
-      console.warn('AI conflict resolution failed, using heuristic approach:', error instanceof Error ? error.message : 'Unknown error');
-    }
-
-    return this.resolveConflictsHeuristic(conflicts, framework);
-  }
-
-  /**
-   * Generate optimizations using AI
-   */
-  async generateOptimizations(framework: FrameworkInfo, patterns: string[]): Promise<string[]> {
-    const request: OptimizationRequest = {
-      framework,
-      patterns,
-      projectContext: 'HumanBehavior SDK integration'
-    };
-
-    if (!this.openai) {
-      return this.generateOptimizationsHeuristic(framework, patterns);
-    }
-
-    try {
-      const prompt = this.buildOptimizationPrompt(request);
-      const response = await this.openai.chat.completions.create({
-        model: this.config.openaiModel,
-        messages: [
-          {
-            role: 'system',
-            content: 'You are an expert at optimizing code integration. Provide specific, actionable recommendations.'
-          },
-          {
-            role: 'user',
-            content: prompt
-          }
-        ],
-        max_tokens: this.config.maxTokens,
-        temperature: this.config.temperature
-      });
-
-      const content = response.choices[0]?.message?.content;
-      if (content) {
-        return this.parseOptimizations(content);
-      }
-    } catch (error) {
-      console.warn('AI optimization generation failed, using heuristic approach:', error instanceof Error ? error.message : 'Unknown error');
-    }
-
-    return this.generateOptimizationsHeuristic(framework, patterns);
-  }
-
-  /**
-   * Perform AI analysis
-   */
-  private async performAIAnalysis(request: AIAnalysisRequest): Promise<AICodeAnalysis> {
-    if (!this.openai) {
-      return this.performHeuristicAnalysis(request);
-    }
-
-    try {
-      const prompt = this.buildAnalysisPrompt(request);
-      const response = await this.openai.chat.completions.create({
-        model: this.config.openaiModel,
-        messages: [
-          {
-            role: 'system',
-            content: 'You are an expert at analyzing code patterns and determining optimal integration strategies. Provide detailed analysis in JSON format.'
-          },
-          {
-            role: 'user',
-            content: prompt
-          }
-        ],
-        max_tokens: this.config.maxTokens,
-        temperature: this.config.temperature,
-        response_format: { type: 'json_object' }
-      });
-
-      const content = response.choices[0]?.message?.content;
-      if (content) {
-        return this.parseAnalysisResult(content);
-      }
-    } catch (error) {
-      console.warn('AI analysis failed, using heuristic approach:', error instanceof Error ? error.message : 'Unknown error');
-    }
-
-    return this.performHeuristicAnalysis(request);
-  }
-
-  /**
-   * Build analysis prompt
-   */
-  private buildAnalysisPrompt(request: AIAnalysisRequest): string {
-    return `Analyze these code samples to determine the framework and integration strategy:
-
-${request.codeSamples.join('\n\n')}
-
-Provide analysis in JSON format with:
-- framework: { name, type, confidence (0-1) }
-- patterns: array of detected patterns
-- conflicts: array of potential conflicts
-- recommendations: array of integration recommendations
-- integrationStrategy: "provider" | "plugin" | "module" | "script" | "standalone"
-- compatibilityMode: "modern" | "legacy" | "hybrid"
-
-Focus on:
-1. Framework detection beyond package.json
-2. Code patterns and architecture
-3. Integration compatibility
-4. Future-proof strategies
-5. Backward compatibility needs
-
-Respond with valid JSON only.`;
-  }
-
-  /**
-   * Build conflict resolution prompt
-   */
-  private buildConflictResolutionPrompt(request: ConflictResolutionRequest): string {
-    return `Resolve these integration conflicts for ${request.framework.name}:
-
-Conflicts: ${request.conflicts.join(', ')}
-
-Framework: ${request.framework.name} (${request.framework.type})
-Context: ${request.codeContext}
-
-Provide specific resolution strategies for each conflict. Options:
-- update_existing_integration: Update existing code
-- merge_providers: Merge multiple providers
-- hybrid_module_support: Support both module systems
-- skip_conflict: Skip the modification
-- custom_resolution: Custom resolution strategy
-
-Respond with a JSON array of resolution strategies.`;
-  }
-
-  /**
-   * Build optimization prompt
-   */
-  private buildOptimizationPrompt(request: OptimizationRequest): string {
-    return `Generate optimizations for ${request.framework.name} integration:
-
-Framework: ${request.framework.name} (${request.framework.type})
-Patterns: ${request.patterns.join(', ')}
-Context: ${request.projectContext}
-
-Provide specific, actionable optimization recommendations for:
-1. Performance improvements
-2. Error handling
-3. Code organization
-4. Future-proofing
-5. Backward compatibility
-
-Respond with a JSON array of optimization recommendations.`;
-  }
-
-  /**
-   * Parse analysis result
-   */
-  private parseAnalysisResult(content: string): AICodeAnalysis {
-    try {
-      const result = JSON.parse(content);
-      return {
-        framework: result.framework || { name: 'vanilla', type: 'vanilla' },
-        confidence: result.confidence || 0.5,
-        patterns: result.patterns || [],
-        conflicts: result.conflicts || [],
-        recommendations: result.recommendations || [],
-        integrationStrategy: result.integrationStrategy || 'script',
-        compatibilityMode: result.compatibilityMode || 'modern'
-      };
-    } catch (error) {
-      console.warn('Failed to parse AI analysis result:', error);
-      return this.getDefaultAnalysis();
-    }
-  }
-
-  /**
-   * Parse conflict resolutions
-   */
-  private parseConflictResolutions(content: string): string[] {
-    try {
-      const result = JSON.parse(content);
-      return Array.isArray(result) ? result : [];
-    } catch (error) {
-      console.warn('Failed to parse conflict resolutions:', error);
-      return [];
-    }
-  }
-
-  /**
-   * Parse optimizations
-   */
-  private parseOptimizations(content: string): string[] {
-    try {
-      const result = JSON.parse(content);
-      return Array.isArray(result) ? result : [];
-    } catch (error) {
-      console.warn('Failed to parse optimizations:', error);
-      return [];
-    }
-  }
-
-  /**
-   * Heuristic analysis fallback
-   */
-  private performHeuristicAnalysis(request: AIAnalysisRequest): AICodeAnalysis {
-    const patterns = request.codeSamples.join(' ').toLowerCase();
-    
-    // Framework detection
-    let framework: FrameworkInfo = { name: 'vanilla', type: 'vanilla' };
-    let confidence = 0.5;
-    
-    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;
-    } else if (patterns.includes('next')) {
-      framework = { name: 'nextjs', type: 'nextjs' };
-      confidence = 0.9;
-    } else if (patterns.includes('nuxt')) {
-      framework = { name: 'nuxt', type: 'nuxt' };
-      confidence = 0.9;
-    }
-    
-    // Integration strategy
-    let integrationStrategy: 'provider' | 'plugin' | 'module' | 'script' | 'standalone' = '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' | 'legacy' | 'hybrid' = 'modern';
-    if (patterns.includes('require(') || patterns.includes('var ')) {
-      compatibilityMode = 'legacy';
-    }
-    
-    return {
-      framework,
-      confidence,
-      patterns: request.codeSamples,
-      conflicts: [],
-      recommendations: [],
-      integrationStrategy,
-      compatibilityMode
-    };
-  }
-
-  /**
-   * Heuristic conflict resolution
-   */
-  private resolveConflictsHeuristic(conflicts: string[], framework: FrameworkInfo): string[] {
-    const resolutions: string[] = [];
-    
-    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
-   */
-  private generateOptimizationsHeuristic(framework: FrameworkInfo, patterns: string[]): string[] {
-    const optimizations: string[] = [];
-    
-    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;
-  }
-
-  /**
-   * Generate cache key
-   */
-  private generateCacheKey(request: AIAnalysisRequest): string {
-    const content = JSON.stringify(request);
-    return Buffer.from(content).toString('base64').substring(0, 32);
-  }
-
-  /**
-   * Check if cache is valid
-   */
-  private isCacheValid(timestamp: number): boolean {
-    const now = Date.now();
-    const ttl = (this.config.cacheTTL || 3600) * 1000; // Convert to milliseconds
-    return (now - timestamp) < ttl;
-  }
-
-  /**
-   * Get default analysis
-   */
-  private getDefaultAnalysis(): AICodeAnalysis {
-    return {
-      framework: { name: 'vanilla', type: 'vanilla' },
-      confidence: 0.5,
-      patterns: [],
-      conflicts: [],
-      recommendations: [],
-      integrationStrategy: 'script',
-      compatibilityMode: 'modern'
-    };
-  }
-
-  /**
-   * Get service statistics
-   */
-  getStats() {
-    return {
-      cacheSize: this.cache.size,
-      config: {
-        model: this.config.openaiModel,
-        maxTokens: this.config.maxTokens,
-        temperature: this.config.temperature,
-        caching: this.config.enableCaching
-      },
-      openaiAvailable: !!this.openai
-    };
-  }
-
-  /**
-   * Clear cache
-   */
-  clearCache() {
-    this.cache.clear();
-  }
-}
-
-/**
- * Express.js server implementation
- */
-export function createAIServiceServer(config: CentralizedAIServiceConfig) {
-  const express = require('express');
-  const app = express();
-  const aiService = new CentralizedAIService(config);
-
-  app.use(express.json());
-
-  // Health check endpoint
-  app.get('/health', (req: any, res: any) => {
-    res.json({ status: 'healthy', stats: aiService.getStats() });
-  });
-
-  // Analysis endpoint
-  app.post('/analyze', async (req: any, res: any) => {
-    try {
-      const { codeSamples, projectType, userAgent } = req.body;
-      
-      if (!codeSamples || !Array.isArray(codeSamples)) {
-        return res.status(400).json({ error: 'codeSamples array is required' });
-      }
-
-      const startTime = Date.now();
-      const analysis = await aiService.analyzeCodePatterns(codeSamples);
-      const processingTime = Date.now() - startTime;
-
-      res.json({
-        analysis,
-        processingTime,
-        modelUsed: config.openaiModel || 'heuristic'
-      });
-    } catch (error) {
-      res.status(500).json({ error: 'Analysis failed', details: error instanceof Error ? error.message : 'Unknown error' });
-    }
-  });
-
-  // Conflict resolution endpoint
-  app.post('/resolve-conflicts', async (req: any, res: any) => {
-    try {
-      const { conflicts, framework } = req.body;
-      
-      if (!conflicts || !framework) {
-        return res.status(400).json({ error: 'conflicts and framework are required' });
-      }
-
-      const resolutions = await aiService.resolveConflicts(conflicts, framework);
-      res.json({ resolutions });
-    } catch (error) {
-      res.status(500).json({ error: 'Conflict resolution failed', details: error instanceof Error ? error.message : 'Unknown error' });
-    }
-  });
-
-  // Optimization endpoint
-  app.post('/optimize', async (req: any, res: any) => {
-    try {
-      const { framework, patterns } = req.body;
-      
-      if (!framework || !patterns) {
-        return res.status(400).json({ error: 'framework and patterns are required' });
-      }
-
-      const optimizations = await aiService.generateOptimizations(framework, patterns);
-      res.json({ optimizations });
-    } catch (error) {
-      res.status(500).json({ error: 'Optimization failed', details: error instanceof Error ? error.message : 'Unknown error' });
-    }
-  });
-
-  return app;
-}
-
-/**
- * AWS Lambda handler
- */
-export async function lambdaHandler(event: any, context: any) {
-  const config: CentralizedAIServiceConfig = {
-    openaiApiKey: process.env.OPENAI_API_KEY!,
-    openaiModel: process.env.OPENAI_MODEL || 'gpt-4',
-    maxTokens: parseInt(process.env.MAX_TOKENS || '2000'),
-    temperature: parseFloat(process.env.TEMPERATURE || '0.3'),
-    enableCaching: process.env.ENABLE_CACHING !== 'false',
-    cacheTTL: parseInt(process.env.CACHE_TTL || '3600')
-  };
-
-  const aiService = new CentralizedAIService(config);
-
-  try {
-    const { path, httpMethod, body } = event;
-    const parsedBody = body ? JSON.parse(body) : {};
-
-    switch (path) {
-      case '/analyze':
-        if (httpMethod !== 'POST') {
-          return { statusCode: 405, body: JSON.stringify({ error: 'Method not allowed' }) };
-        }
-        
-        const analysis = await aiService.analyzeCodePatterns(parsedBody.codeSamples || []);
-        return {
-          statusCode: 200,
-          body: JSON.stringify({ analysis })
-        };
-
-      case '/resolve-conflicts':
-        if (httpMethod !== 'POST') {
-          return { statusCode: 405, body: JSON.stringify({ error: 'Method not allowed' }) };
-        }
-        
-        const resolutions = await aiService.resolveConflicts(
-          parsedBody.conflicts || [],
-          parsedBody.framework || { name: 'vanilla', type: 'vanilla' }
-        );
-        return {
-          statusCode: 200,
-          body: JSON.stringify({ resolutions })
-        };
-
-      default:
-        return { statusCode: 404, body: JSON.stringify({ error: 'Not found' }) };
-    }
-  } catch (error) {
-    return {
-      statusCode: 500,
-      body: JSON.stringify({ error: 'Internal server error', details: error instanceof Error ? error.message : 'Unknown error' })
-    };
-  }
-}