guideai-app 0.3.1 → 0.3.4

package/dist/components/TranscriptBox.d.ts

@@ -13,5 +13,5 @@ interface TranscriptBoxProps {
     onTextKeyPress?: (event: React.KeyboardEvent) => void;
     textPlaceholder?: string;
 }
-declare const TranscriptBox: React.FC<TranscriptBoxProps>;
+declare const TranscriptBox: React.NamedExoticComponent<TranscriptBoxProps>;
 export default TranscriptBox;

package/dist/metric/event-listner.d.ts

@@ -33,18 +33,31 @@ declare class EventTracker {
     private pendingEvents;
     private currentUrl;
     private organizationKey?;
+    private lastEventTime;
+    private eventThrottleInterval;
+    private lastEventsByType;
+    private duplicateEventBuffer;
+    private maxDuplicateBuffer;
+    private isInitialized;
     private customerMetadata;
     constructor(options?: {
         customerId?: string;
         customerType?: string;
         organizationId?: string;
         organizationKey?: string;
+        batchSize?: number;
+        batchTimeout?: number;
+        eventThrottleInterval?: number;
     });
+    private init;
+    private loadEventsFromStorage;
+    private saveEventsToStorage;
     setCustomerMetadata(metadata: Partial<typeof this.customerMetadata>): void;
     getCustomerMetadata(): typeof this.customerMetadata;
     clearCustomerMetadata(): void;
     initialize(): void;
     private enrichEventData;
+    private sanitizeEventData;
     private getSessionId;
     private getDeviceType;
     startTracking(): void;
@@ -65,6 +78,12 @@ declare class EventTracker {
     private getSafeValue;
     private isFocusable;
     private isFormElement;
+    private generateEventKey;
+    private shouldThrottleEvent;
+    private isDuplicateEvent;
+    private isSignificantClickTarget;
+    private isSignificantFocusTarget;
+    private isSignificantRouteChange;
     private logEvent;
     private startBatchTimer;
     private emitBatch;

package/dist/metric/metadata-tracker.d.ts

@@ -6,11 +6,18 @@ declare class UserMetadataTracker {
     private pendingUpdates;
     private isInitialized;
     private onError?;
+    private lastSyncTime;
+    private minSyncInterval;
+    private lastMetadataHash;
+    private pendingUpdateTypes;
     constructor(organizationKey: string, config?: MetadataConfig, onError?: (error: Error, context: string) => void);
-    private init;
+    init(): void;
     updateUserInfo(userInfo: Partial<UserMetadata>): void;
     trackLogin(additionalInfo?: Partial<UserMetadata>): void;
+    private trackVisitOncePerSession;
     trackVisit(): void;
+    resetSessionVisitTracking(): void;
+    trackVisitManually(): void;
     trackCustomEvent(eventType: string, customData: Record<string, any>): void;
     getMetadata(): UserMetadata;
     getPendingUpdates(): MetadataUpdate[];
@@ -21,6 +28,10 @@ declare class UserMetadataTracker {
     private collectBrowserInfo;
     private parseBrowserInfo;
     private startSyncTimer;
+    private shouldSync;
+    private addPendingUpdate;
+    private isDataDuplicate;
+    private generateDataHash;
     private setupEventTrackerIntegration;
     private stopSyncTimer;
     private emitPendingUpdates;

package/dist/utils/logger.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Standardized logging utility for GuideAI package
+ * Provides consistent formatting and development gating across all components
+ */
+type Component = 'GuideAI' | 'EventTracker' | 'UserMetadata' | 'API' | 'TranscriptBox' | 'Onboarding';
+declare class Logger {
+    private static formatMessage;
+    /**
+     * Standard info logging - only in development
+     */
+    static log(component: Component, action: string, data?: any): void;
+    /**
+     * Warning logging - always shown
+     */
+    static warn(component: Component, action: string, data?: any): void;
+    /**
+     * Error logging - always shown
+     */
+    static error(component: Component, action: string, error?: any): void;
+    /**
+     * API call logging with method and endpoint
+     */
+    static apiCall(method: string, endpoint: string, data?: any): void;
+    /**
+     * API response logging
+     */
+    static apiResponse(method: string, endpoint: string, success: boolean, data?: any): void;
+    /**
+     * Conversation flow tracking
+     */
+    static conversation(action: string, data?: any): void;
+    /**
+     * Event tracking logging
+     */
+    static event(action: string, data?: any): void;
+    /**
+     * Metadata tracking logging
+     */
+    static metadata(action: string, data?: any): void;
+}
+export default Logger;

package/dist/utils/workflow.d.ts

@@ -0,0 +1,62 @@
+import { Workflow } from './api';
+export interface WorkflowTrigger {
+    triggerWords: string[];
+    workflowKey: string;
+    description?: string;
+}
+export interface WorkflowLogEvent {
+    type: 'workflow_init' | 'trigger_detected' | 'workflow_activated';
+    timestamp: string;
+    data: any;
+}
+/**
+ * Format a workflow log message for console output
+ */
+export declare const formatWorkflowLog: (event: WorkflowLogEvent) => string;
+/**
+ * Log workflow event to console with formatting
+ */
+export declare const logWorkflowEvent: (event: WorkflowLogEvent) => void;
+/**
+ * Detect which workflows should be triggered based on a user message
+ * @param message The user's message
+ * @param workflows Array of available workflows
+ * @returns Array of workflows that should be triggered
+ */
+export declare const detectWorkflowTriggers: (message: string, workflows: Workflow[]) => Workflow[];
+/**
+ * Get trigger words from a message that match a specific workflow
+ * @param message The user's message
+ * @param workflow The workflow to check against
+ * @returns Array of detected trigger words for this workflow
+ */
+export declare const getWorkflowTriggerWords: (message: string, workflow: Workflow) => string[];
+/**
+ * Check if a message contains any trigger words for any workflow
+ * @param message The user's message
+ * @param workflows Array of available workflows
+ * @returns True if any workflow triggers are found
+ */
+export declare const hasWorkflowTriggers: (message: string, workflows: Workflow[]) => boolean;
+/**
+ * Get the most relevant workflow for a message
+ * @param message The user's message
+ * @param workflows Array of available workflows
+ * @returns The most relevant workflow or null if none found
+ */
+export declare const getMostRelevantWorkflow: (message: string, workflows: Workflow[]) => Workflow | null;
+/**
+ * Legacy function for backward compatibility
+ * @deprecated Use detectWorkflowTriggers instead
+ */
+export declare const detectTriggerWords: (message: string, triggerWords: string[]) => string[];
+/**
+ * Legacy function for backward compatibility
+ * @deprecated Use hasWorkflowTriggers instead
+ */
+export declare const hasTriggerWords: (message: string, triggerWords: string[]) => boolean;
+/**
+ * Legacy function for backward compatibility
+ * @deprecated Use getMostRelevantWorkflow instead
+ */
+export declare const getMostRelevantTrigger: (message: string, triggerWords: string[]) => string | null;

package/metadata-tracking-example.md

@@ -0,0 +1,324 @@
+# User Metadata Tracking - Implementation Guide
+
+## Overview
+
+The GuideAI package now includes comprehensive user metadata tracking capabilities designed for integration with Overproof. This system tracks the following metadata:
+
+- **User's First Visit** - Timestamp of the first time the user interacted with GuideAI
+- **User's Last Visit** - Timestamp of the most recent user interaction
+- **User Logins** - Count and timestamp of login events
+- **User Type** - Classification of the user (agent, admin, manager, customer, guest, etc.)
+- **Customer Type** - Type of customer (individual, business, enterprise, etc.)
+- **Customer License** - License identifier for the customer
+
+## Basic Usage
+
+### 1. Basic Integration
+
+```typescript
+import { GuideAI } from 'guide-ai-package';
+
+function App() {
+  return (
+    <GuideAI 
+      organizationKey="your-org-key"
+      metadata={{
+        config: {
+          trackVisits: true,
+          trackLogins: true,
+          syncInterval: 30000, // Sync every 30 seconds
+          storage: 'localStorage'
+        },
+        initialUserData: {
+          userType: 'agent',
+          customerType: 'business',
+          customerLicense: 'OVERPRF-12345'
+        },
+        onMetadataUpdate: (metadata) => {
+          console.log('Metadata updated:', metadata);
+          // Send to your analytics system
+        }
+      }}
+    />
+  );
+}
+```
+
+### 2. Tracking User Login Events
+
+```typescript
+import { useRef } from 'react';
+
+function LoginComponent() {
+  const guideAIRef = useRef();
+
+  const handleLogin = async (userInfo) => {
+    // Your login logic here
+    const loginResult = await performLogin(userInfo);
+    
+    if (loginResult.success) {
+      // Track the login with GuideAI
+      guideAIRef.current?.trackLogin({
+        userId: loginResult.userId,
+        userType: loginResult.userType,
+        customerType: loginResult.customerType,
+        customerLicense: loginResult.license
+      });
+    }
+  };
+
+  return (
+    <div>
+      <GuideAI 
+        ref={guideAIRef}
+        organizationKey="your-org-key"
+        metadata={{
+          config: { trackLogins: true }
+        }}
+      />
+      <button onClick={handleLogin}>Login</button>
+    </div>
+  );
+}
+```
+
+### 3. Updating User Information
+
+```typescript
+function UserProfileComponent() {
+  const guideAIRef = useRef();
+
+  const updateUserProfile = (newUserData) => {
+    // Update user profile in your system
+    saveUserProfile(newUserData);
+    
+    // Update GuideAI metadata
+    guideAIRef.current?.updateUserInfo({
+      userType: newUserData.role,
+      customerType: newUserData.accountType,
+      customerLicense: newUserData.license,
+      customFields: {
+        department: newUserData.department,
+        region: newUserData.region
+      }
+    });
+  };
+
+  return (
+    <GuideAI 
+      ref={guideAIRef}
+      organizationKey="your-org-key"
+      metadata={{
+        config: {
+          customFields: ['department', 'region'],
+          collectBrowserInfo: true
+        }
+      }}
+    />
+  );
+}
+```
+
+## Configuration Options
+
+### MetadataConfig
+
+```typescript
+interface MetadataConfig {
+  // Whether to automatically track visits (default: true)
+  trackVisits?: boolean;
+  
+  // Whether to automatically track logins (default: true)
+  trackLogins?: boolean;
+  
+  // How often to sync metadata to backend in milliseconds (default: 30000)
+  syncInterval?: number;
+  
+  // Storage strategy (default: 'localStorage')
+  storage?: 'localStorage' | 'sessionStorage' | 'memory';
+  
+  // Custom metadata fields to collect
+  customFields?: string[];
+  
+  // Whether to collect browser information (default: true)
+  collectBrowserInfo?: boolean;
+  
+  // Whether to collect user agent (default: true)
+  collectUserAgent?: boolean;
+}
+```
+
+### UserMetadata Structure
+
+```typescript
+interface UserMetadata {
+  // Core identification
+  userId?: string;
+  userType?: 'agent' | 'admin' | 'manager' | 'customer' | 'guest' | string;
+  
+  // Customer-specific metadata
+  customerType?: 'individual' | 'business' | 'enterprise' | string;
+  customerLicense?: string;
+  
+  // Visit tracking (automatically managed)
+  firstVisit?: number; // timestamp
+  lastVisit?: number; // timestamp
+  visitCount?: number;
+  
+  // Login tracking (requires manual tracking)
+  loginCount?: number;
+  lastLogin?: number; // timestamp
+  
+  // Session metadata (automatically managed)
+  organizationKey: string;
+  sessionId?: string;
+  
+  // Browser information (automatically collected if enabled)
+  userAgent?: string;
+  browserInfo?: {
+    name?: string;
+    version?: string;
+    platform?: string;
+  };
+  
+  // Custom fields for Overproof-specific needs
+  customFields?: Record<string, string | number | boolean>;
+}
+```
+
+## API Integration
+
+The system automatically sends metadata updates to these endpoints:
+
+### POST `/user-metadata`
+Sends complete user metadata object when initially collected.
+
+### POST `/metadata-updates` 
+Sends batched metadata updates periodically.
+
+### PATCH `/users/{userId}/metadata`
+Updates specific user metadata when userId is available.
+
+## Backend Implementation
+
+You'll need to implement these endpoints in your backend:
+
+```typescript
+// Example Express.js implementation
+app.post('/api/user-metadata', (req, res) => {
+  const { organizationKey, metadata, timestamp } = req.body;
+  
+  // Store metadata in your database
+  await UserMetadata.upsert({
+    organizationKey,
+    userId: metadata.userId || 'anonymous',
+    ...metadata,
+    lastUpdated: new Date(timestamp)
+  });
+  
+  res.json({ success: true });
+});
+
+app.post('/api/metadata-updates', (req, res) => {
+  const { organizationKey, updates, batchTimestamp } = req.body;
+  
+  // Process batch updates
+  for (const update of updates) {
+    await processMetadataUpdate(organizationKey, update);
+  }
+  
+  res.json({ success: true });
+});
+```
+
+## Privacy Considerations
+
+- **User Agent Collection**: Can be disabled via `collectUserAgent: false`
+- **Browser Info Collection**: Can be disabled via `collectBrowserInfo: false`
+- **Custom Fields**: Only fields specified in `customFields` array are collected
+- **Storage**: Can be set to `'memory'` for session-only storage without persistence
+
+## Testing
+
+```typescript
+// Get current metadata
+const metadata = guideAIRef.current?.getMetadata();
+console.log('Current metadata:', metadata);
+
+// Force sync metadata now
+await guideAIRef.current?.syncMetadata();
+
+// Track custom events
+guideAIRef.current?.trackCustomEvent('document_viewed', {
+  documentType: 'policy',
+  documentId: 'POL-12345'
+});
+```
+
+## Overproof Integration Example
+
+```typescript
+function OverproofApp() {
+  const guideAIRef = useRef();
+
+  // Track when user logs into Overproof
+  const handleOverproofLogin = (user) => {
+    guideAIRef.current?.trackLogin({
+      userId: user.id,
+      userType: user.role, // 'agent', 'admin', etc.
+      customerType: user.accountType,
+      customerLicense: user.licenseNumber,
+      customFields: {
+        agencyId: user.agencyId,
+        territory: user.territory,
+        permissions: user.permissions.join(',')
+      }
+    });
+  };
+
+  // Track when user profile is updated
+  const handleProfileUpdate = (updatedProfile) => {
+    guideAIRef.current?.updateUserInfo({
+      userType: updatedProfile.role,
+      customerLicense: updatedProfile.licenseNumber,
+      customFields: {
+        agencyId: updatedProfile.agencyId,
+        territory: updatedProfile.territory
+      }
+    });
+  };
+
+  return (
+    <GuideAI 
+      ref={guideAIRef}
+      organizationKey="overproof-org-key"
+      metadata={{
+        config: {
+          trackVisits: true,
+          trackLogins: true,
+          syncInterval: 15000, // More frequent syncing for Overproof
+          customFields: ['agencyId', 'territory', 'permissions'],
+          collectBrowserInfo: true
+        },
+        onMetadataUpdate: (metadata) => {
+          // Send to Overproof analytics
+          window.OverproofAnalytics?.track('guideai_metadata_update', metadata);
+        }
+      }}
+    />
+  );
+}
+```
+
+## Storage and Data Persistence
+
+- **localStorage**: Persists across browser sessions (default)
+- **sessionStorage**: Persists only for current session
+- **memory**: No persistence, data lost on page refresh
+
+Metadata is automatically:
+- Saved locally based on storage configuration
+- Synced to backend at configured intervals
+- Restored when user returns (if using persistent storage)
+
+This implementation provides a robust foundation for tracking user metadata in the Overproof environment while maintaining flexibility for other use cases.

package/obfuscate.js

@@ -0,0 +1,40 @@
+const fs = require('fs');
+const path = require('path');
+const JavaScriptObfuscator = require('javascript-obfuscator');
+
+// Files to obfuscate
+const files = [
+  'dist/index.js',
+  'dist/index.esm.js'
+];
+
+// Load obfuscator config
+const config = JSON.parse(fs.readFileSync(path.resolve(__dirname, 'obfuscator.json'), 'utf8'));
+
+// Process each file
+
+files.forEach(file => {
+  const filePath = path.resolve(__dirname, file);
+  
+  try {
+    // Check if file exists
+    if (!fs.existsSync(filePath)) {
+      console.warn(`Warning: ${file} does not exist, skipping obfuscation.`);
+      return;
+    }
+    
+    
+    // Read the file
+    const code = fs.readFileSync(filePath, 'utf8');
+    
+    // Obfuscate the code
+    const obfuscationResult = JavaScriptObfuscator.obfuscate(code, config);
+    
+    // Write the obfuscated code back to the file
+    fs.writeFileSync(filePath, obfuscationResult.getObfuscatedCode());
+    
+  } catch (error) {
+    console.error(`Error obfuscating ${file}:`, error);
+    process.exit(1);
+  }
+});

package/obfuscator.prod.json

@@ -0,0 +1,24 @@
+{
+  "compact": true,
+  "controlFlowFlattening": false,
+  "controlFlowFlatteningThreshold": 0.75,
+  "deadCodeInjection": false,
+  "deadCodeInjectionThreshold": 0.4,
+  "debugProtection": false,
+  "debugProtectionInterval": 0,
+  "disableConsoleOutput": true,
+  "identifierNamesGenerator": "hexadecimal",
+  "log": false,
+  "numbersToExpressions": false,
+  "renameGlobals": false,
+  "rotateStringArray": false,
+  "selfDefending": false,
+  "shuffleStringArray": false,
+  "splitStrings": false,
+  "splitStringsChunkLength": 10,
+  "stringArray": false,
+  "stringArrayEncoding": [],
+  "stringArrayThreshold": 0,
+  "transformObjectKeys": false,
+  "unicodeEscapeSequence": false
+} 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "guideai-app",
-  "version": "0.3.1",
+  "version": "0.3.4",
   "description": "AI-powered guide component for React applications",
   "main": "dist/GuideAI.js",
   "types": "dist/GuideAI.d.ts",