humanbehavior-js 0.4.16 → 0.4.17

package/package/src/types/clack.d.ts

@@ -0,0 +1,31 @@
+declare module '@clack/prompts' {
+  export function intro(message: string): void;
+  export function outro(message: string): void;
+  export function cancel(message: string): void;
+  export function note(message: string, title?: string): void;
+  
+  export function text(options: {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    validate?: (value: string) => string | undefined;
+  }): Promise<string>;
+  
+  export function select(options: {
+    message: string;
+    options: Array<{
+      label: string;
+      value: string;
+      hint?: string;
+    }>;
+  }): Promise<string>;
+  
+  export function confirm(options: {
+    message: string;
+  }): Promise<boolean>;
+  
+  export function spinner(): {
+    start(message: string): void;
+    stop(message?: string): void;
+  };
+}

package/package/src/utils/logger.ts

@@ -0,0 +1,144 @@
+export enum LogLevel {
+  NONE = 0,
+  ERROR = 1,
+  WARN = 2,
+  INFO = 3,
+  DEBUG = 4
+}
+
+export interface LoggerConfig {
+  level: LogLevel;
+  enableConsole: boolean;
+  enableStorage: boolean;
+}
+
+class Logger {
+  private config: LoggerConfig = {
+    level: LogLevel.ERROR, // Default to only errors in production
+    enableConsole: true,
+    enableStorage: false
+  };
+
+  private isBrowser = typeof window !== 'undefined';
+
+  constructor(config?: Partial<LoggerConfig>) {
+    if (config) {
+      this.config = { ...this.config, ...config };
+    }
+  }
+
+  setConfig(config: Partial<LoggerConfig>): void {
+    this.config = { ...this.config, ...config };
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return level <= this.config.level;
+  }
+
+  private formatMessage(level: string, message: string, ...args: any[]): string {
+    const timestamp = new Date().toISOString();
+    return `[HumanBehavior ${level}] ${timestamp}: ${message}`;
+  }
+
+  error(message: string, ...args: any[]): void {
+    if (!this.shouldLog(LogLevel.ERROR)) return;
+    
+    const formattedMessage = this.formatMessage('ERROR', message);
+    
+    if (this.config.enableConsole) {
+      console.error(formattedMessage, ...args);
+    }
+    
+    if (this.config.enableStorage && this.isBrowser) {
+      this.logToStorage(formattedMessage, args);
+    }
+  }
+
+  warn(message: string, ...args: any[]): void {
+    if (!this.shouldLog(LogLevel.WARN)) return;
+    
+    const formattedMessage = this.formatMessage('WARN', message);
+    
+    if (this.config.enableConsole) {
+      console.warn(formattedMessage, ...args);
+    }
+    
+    if (this.config.enableStorage && this.isBrowser) {
+      this.logToStorage(formattedMessage, args);
+    }
+  }
+
+  info(message: string, ...args: any[]): void {
+    if (!this.shouldLog(LogLevel.INFO)) return;
+    
+    const formattedMessage = this.formatMessage('INFO', message);
+    
+    if (this.config.enableConsole) {
+      console.log(formattedMessage, ...args);
+    }
+    
+    if (this.config.enableStorage && this.isBrowser) {
+      this.logToStorage(formattedMessage, args);
+    }
+  }
+
+  debug(message: string, ...args: any[]): void {
+    if (!this.shouldLog(LogLevel.DEBUG)) return;
+    
+    const formattedMessage = this.formatMessage('DEBUG', message);
+    
+    if (this.config.enableConsole) {
+      console.log(formattedMessage, ...args);
+    }
+    
+    if (this.config.enableStorage && this.isBrowser) {
+      this.logToStorage(formattedMessage, args);
+    }
+  }
+
+  private logToStorage(message: string, args: any[]): void {
+    try {
+      const logs = JSON.parse(localStorage.getItem('human_behavior_logs') || '[]');
+      const logEntry = {
+        message,
+        args: args.length > 0 ? args : undefined,
+        timestamp: Date.now()
+      };
+      logs.push(logEntry);
+      
+      // Keep only last 1000 logs to prevent storage bloat
+      if (logs.length > 1000) {
+        logs.splice(0, logs.length - 1000);
+      }
+      
+      localStorage.setItem('human_behavior_logs', JSON.stringify(logs));
+    } catch (e) {
+      // Silently fail if storage is not available
+    }
+  }
+
+  getLogs(): any[] {
+    if (!this.isBrowser) return [];
+    
+    try {
+      return JSON.parse(localStorage.getItem('human_behavior_logs') || '[]');
+    } catch (e) {
+      return [];
+    }
+  }
+
+  clearLogs(): void {
+    if (this.isBrowser) {
+      localStorage.removeItem('human_behavior_logs');
+    }
+  }
+}
+
+// Create singleton instance
+export const logger = new Logger();
+
+// Export convenience methods
+export const logError = (message: string, ...args: any[]) => logger.error(message, ...args);
+export const logWarn = (message: string, ...args: any[]) => logger.warn(message, ...args);
+export const logInfo = (message: string, ...args: any[]) => logger.info(message, ...args);
+export const logDebug = (message: string, ...args: any[]) => logger.debug(message, ...args); 

package/package/src/vue/index.ts

@@ -0,0 +1,29 @@
+import { HumanBehaviorTracker } from '../index.js';
+import type { App } from 'vue';
+
+interface HumanBehaviorPluginOptions {
+  apiKey: string;
+  ingestionUrl?: string;
+  logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
+  redactFields?: string[];
+  suppressConsoleErrors?: boolean;
+  recordCanvas?: boolean; // Enable canvas recording with PostHog-style protection
+}
+
+export const HumanBehaviorPlugin = {
+  install: (app: App, options: HumanBehaviorPluginOptions) => {
+    const tracker = HumanBehaviorTracker.init(options.apiKey, {
+      ingestionUrl: options.ingestionUrl,
+      logLevel: options.logLevel,
+      redactFields: options.redactFields,
+      suppressConsoleErrors: options.suppressConsoleErrors,
+      recordCanvas: options.recordCanvas, // Pass canvas recording option
+    });
+    
+    // Make tracker available globally
+    app.config.globalProperties.$humanBehavior = tracker;
+    
+    // Also provide it via inject/provide
+    app.provide('humanBehavior', tracker);
+  }
+}; 

package/package/src/wizard/README.md

@@ -0,0 +1,114 @@
+# HumanBehavior SDK Wizard Module
+
+This module provides AI-enhanced auto-installation capabilities for the HumanBehavior SDK.
+
+## 📁 Directory Structure
+
+```
+src/wizard/
+├── core/           # Core installation wizard
+│   └── install-wizard.ts
+├── ai/             # AI-enhanced wizard components
+│   └── ai-install-wizard.ts
+├── cli/            # Command-line interfaces
+│   ├── auto-install.ts
+│   └── ai-auto-install.ts
+├── services/       # AI service implementations
+│   ├── remote-ai-service.ts
+│   └── centralized-ai-service.ts
+├── index.ts        # Main exports
+└── README.md       # This file
+```
+
+## 🚀 Key Components
+
+### Core (`core/`)
+- **`install-wizard.ts`**: Traditional installation wizard
+- Framework detection and code modification
+- Environment variable management
+- Package installation
+
+### AI (`ai/`)
+- **`ai-install-wizard.ts`**: AI-enhanced installation wizard
+- AI-powered framework detection
+- Intelligent code analysis
+- Conflict resolution
+- Learning system
+
+### CLI (`cli/`)
+- **`auto-install.ts`**: Traditional CLI interface
+- **`ai-auto-install.ts`**: AI-enhanced CLI interface
+- User interaction and command parsing
+- Installation mode selection
+
+### Services (`services/`)
+- **`remote-ai-service.ts`**: Connects to deployed Lambda AI service
+- **`centralized-ai-service.ts`**: Local AI service implementation
+- Heuristic fallback when AI is unavailable
+
+## 🔧 Usage
+
+### Traditional Installation
+```typescript
+import { AutoInstallationWizard } from 'humanbehavior-js/wizard';
+
+const wizard = new AutoInstallationWizard(apiKey, projectPath);
+const result = await wizard.install();
+```
+
+### AI-Enhanced Installation
+```typescript
+import { AIEnhancedInstallationWizard, RemoteAIService } from 'humanbehavior-js/wizard';
+
+const aiService = new RemoteAIService({
+  apiEndpoint: 'https://your-lambda-api.execute-api.region.amazonaws.com/prod'
+});
+
+const wizard = new AIEnhancedInstallationWizard(apiKey, projectPath, aiService);
+const result = await wizard.install();
+```
+
+### CLI Usage
+```bash
+# Traditional installation
+npx humanbehavior-js auto-install YOUR_API_KEY
+
+# AI-enhanced installation
+npx humanbehavior-js ai-auto-install YOUR_API_KEY --ai
+```
+
+## 🧠 AI Features
+
+- **Intelligent Framework Detection**: Beyond package.json analysis
+- **Code Pattern Analysis**: Understands project structure and patterns
+- **Conflict Resolution**: Smart handling of existing integrations
+- **Future-Proofing**: Adaptive strategies for new frameworks
+- **Learning System**: Improves over time with usage patterns
+
+## 🔄 Backward Compatibility
+
+All existing imports continue to work:
+- `humanbehavior-js/install-wizard` → `humanbehavior-js/wizard`
+- Traditional wizard functionality unchanged
+- AI features are additive, not breaking
+
+## 🚀 Lambda Deployment
+
+The `lambda-deployment/` directory contains the AI service for AWS Lambda deployment. This is separate from the client-side wizard code and should not be modified unless deploying AI service updates.
+
+### 📁 Lambda Deployment Structure
+```
+lambda-deployment/
+├── index.js                    # Lambda entry point
+├── ai-install-wizard.ts        # AI service implementation  
+├── install-wizard.ts           # Core wizard logic
+├── centralized-ai-service.ts   # AI service interface
+└── README.md                   # Deployment documentation
+```
+
+### 🔗 Client-Server Relationship
+- **Client**: `src/wizard/` - User-facing installation wizard
+- **Server**: `lambda-deployment/` - AI service backend
+- **Connection**: `RemoteAIService` connects client to Lambda
+
+See `lambda-deployment/README.md` for detailed deployment instructions.