ask-junkie 1.0.0

package/src/core/AskJunkie.js

@@ -0,0 +1,585 @@
+/**
+ * Ask Junkie SDK - Main SDK Class
+ * Handles initialization, configuration, and orchestration
+ */
+
+import { ChatWidget } from '../ui/ChatWidget.js';
+import { AIProviderFactory } from '../ai/AIProviderFactory.js';
+import { FirebaseLogger } from '../analytics/FirebaseLogger.js';
+import { StorageManager } from '../utils/StorageManager.js';
+import { EventEmitter } from './EventEmitter.js';
+
+class AskJunkie {
+    static instance = null;
+    static VERSION = '1.1.1';
+
+    constructor() {
+        this.config = null;
+        this.widget = null;
+        this.aiProvider = null;
+        this.analytics = null;
+        this.storage = null;
+        this.events = new EventEmitter();
+        this.chatHistory = [];
+        this.isInitialized = false;
+        this.siteId = null;
+    }
+
+    /**
+     * Initialize the SDK with configuration
+     * @param {Object} config - Configuration options
+     */
+    static async init(config = {}) {
+        if (AskJunkie.instance && AskJunkie.instance.isInitialized) {
+            console.warn('[AskJunkie] Already initialized. Call destroy() first to reinitialize.');
+            return AskJunkie.instance;
+        }
+
+        AskJunkie.instance = new AskJunkie();
+
+        // Check if using sdkKey mode (fetches settings from dashboard)
+        if (config.sdkKey) {
+            await AskJunkie.instance._initializeWithSdkKey(config.sdkKey, config);
+        } else {
+            AskJunkie.instance._initialize(config);
+        }
+
+        return AskJunkie.instance;
+    }
+
+    /**
+     * Initialize using SDK key - fetches settings from Firebase dashboard
+     */
+    async _initializeWithSdkKey(sdkKey, overrides = {}) {
+        console.log('[AskJunkie] Initializing with SDK key...');
+
+        try {
+            // Fetch settings from Firebase
+            const settings = await this._fetchSettingsFromDashboard(sdkKey);
+
+            if (!settings) {
+                console.error('[AskJunkie] Invalid SDK key or site not found.');
+                return;
+            }
+
+            // Merge fetched settings with any overrides
+            const config = {
+                apiKey: settings.providerApiKey,
+                provider: settings.provider,
+                model: settings.model,
+                botName: settings.botName,
+                welcomeMessage: settings.welcomeMessage,
+                suggestions: settings.suggestions,
+                animatedSuggestions: settings.animatedSuggestions,
+                position: settings.position,
+                draggable: settings.draggable,
+                resizable: settings.resizable,
+                voiceInput: settings.speechToText,  // Map speechToText to voiceInput
+                enabled: settings.enabled,
+                theme: settings.theme,
+                context: settings.context,
+                analytics: {
+                    enabled: true,
+                    siteId: this.siteId,
+                    userId: this.userId  // Pass userId for new nested path
+                },
+                ...overrides,
+                _sdkKey: sdkKey
+            };
+
+            this._initialize(config);
+
+        } catch (error) {
+            console.error('[AskJunkie] Error fetching settings:', error);
+            if (overrides.onError) {
+                overrides.onError(error);
+            }
+        }
+    }
+
+    /**
+     * Fetch settings from Firebase dashboard
+     */
+    async _fetchSettingsFromDashboard(sdkKey) {
+        const FIREBASE_PROJECT = 'ai-chatbot-fe4a2';
+        const API_URL = `https://firestore.googleapis.com/v1/projects/${FIREBASE_PROJECT}/databases/(default)/documents`;
+
+        try {
+            // Step 1: Get the key lookup from sdkKeys collection
+            // Document ID is the SDK key itself
+            const lookupUrl = `${API_URL}/sdkKeys/${sdkKey}`;
+            const lookupResponse = await fetch(lookupUrl);
+
+            if (!lookupResponse.ok) {
+                console.error('[AskJunkie] SDK key not found in lookup');
+                return null;
+            }
+
+            const lookupData = await lookupResponse.json();
+
+            if (!lookupData.fields) {
+                console.error('[AskJunkie] SDK key not found');
+                return null;
+            }
+
+            const userId = lookupData.fields.userId.stringValue;
+            const keyId = lookupData.fields.keyId.stringValue;
+            const status = lookupData.fields.status?.stringValue;
+
+            this.siteId = keyId;
+            this.userId = userId;
+
+            // Check if key is active
+            if (status !== 'active') {
+                console.error('[AskJunkie] SDK key is not active');
+                return null;
+            }
+
+            // Step 2: Fetch the full API key document with settings
+            const keyUrl = `${API_URL}/users/${userId}/apiKeys/${keyId}`;
+            const keyResponse = await fetch(keyUrl);
+
+            if (!keyResponse.ok) {
+                console.error('[AskJunkie] Could not fetch API key details');
+                return null;
+            }
+
+            const keyData = await keyResponse.json();
+
+            if (!keyData.fields) {
+                console.error('[AskJunkie] API key document not found');
+                return null;
+            }
+
+            // Settings are embedded in the API key document
+            if (!keyData.fields.settings) {
+                console.warn('[AskJunkie] No settings configured in dashboard. Using defaults.');
+                return this._getDefaultSettings();
+            }
+
+            // Parse Firestore format to plain object
+            return this._parseFirestoreSettings(keyData.fields.settings.mapValue.fields);
+
+        } catch (error) {
+            console.error('[AskJunkie] Error fetching from Firebase:', error);
+            return null;
+        }
+    }
+
+    /**
+     * Get default settings for SDK
+     */
+    _getDefaultSettings() {
+        return {
+            enabled: true,
+            botName: 'AI Assistant',
+            welcomeMessage: "Hi! 👋 I'm your AI assistant. How can I help you today?",
+            suggestions: [],
+            animatedSuggestions: true,
+            speechToText: true,
+            provider: 'groq',
+            providerApiKey: '', // User must provide in overrides
+            model: 'llama-3.3-70b-versatile',
+            position: 'bottom-right',
+            draggable: true,
+            resizable: false,
+            theme: {
+                mode: 'gradient',
+                preset: 1,
+                primary: '#6366f1',
+                secondary: '#ec4899'
+            },
+            context: {
+                siteName: document.title || 'Website',
+                siteDescription: '',
+                customInfo: '',
+                restrictions: ''
+            }
+        };
+    }
+
+    /**
+     * Parse Firestore document format to plain object
+     */
+    _parseFirestoreSettings(fields) {
+        const getString = (field) => field?.stringValue || '';
+        const getNumber = (field) => field?.integerValue || field?.doubleValue || 0;
+        const getBool = (field) => field?.booleanValue || false;
+        const getArray = (field) => {
+            if (!field?.arrayValue?.values) return [];
+            return field.arrayValue.values.map(v => v.stringValue || '');
+        };
+
+        const themeFields = fields.theme?.mapValue?.fields || {};
+        const contextFields = fields.context?.mapValue?.fields || {};
+
+        return {
+            enabled: fields.enabled?.booleanValue !== false, // Default true if not set
+            botName: getString(fields.botName) || 'AI Assistant',
+            welcomeMessage: getString(fields.welcomeMessage) || "Hi! 👋 I'm your AI assistant.",
+            suggestions: getArray(fields.suggestions),
+            animatedSuggestions: fields.animatedSuggestions?.booleanValue !== false, // Default true
+            speechToText: fields.speechToText?.booleanValue !== false, // Default true
+            provider: getString(fields.provider) || 'groq',
+            providerApiKey: getString(fields.providerApiKey),
+            model: getString(fields.model),
+            position: getString(fields.position) || 'bottom-right',
+            draggable: getBool(fields.draggable),
+            resizable: getBool(fields.resizable),
+            theme: {
+                mode: getString(themeFields.mode) || 'gradient',
+                preset: getNumber(themeFields.preset) || 1,
+                primary: getString(themeFields.primary) || '#6366f1',
+                secondary: getString(themeFields.secondary) || '#ec4899'
+            },
+            context: {
+                siteName: getString(contextFields.siteName),
+                siteDescription: getString(contextFields.siteDescription),
+                customInfo: getString(contextFields.customInfo),
+                restrictions: getString(contextFields.restrictions)
+            }
+        };
+    }
+
+    /**
+     * Internal initialization logic
+     */
+    _initialize(config) {
+        // Merge with defaults
+        this.config = this._mergeConfig(config);
+
+        // Check if chatbot is enabled
+        if (this.config.enabled === false) {
+            console.log('[AskJunkie] Chatbot is disabled in settings. Widget will not render.');
+            this.isInitialized = true;
+            return;
+        }
+
+        // Validate required config
+        if (!this.config.apiKey && !this.config._sdkKey) {
+            console.error('[AskJunkie] API key or SDK key is required.');
+            return;
+        }
+
+        // Initialize storage manager
+        this.storage = new StorageManager(this.config.storagePrefix);
+
+        // Load chat history from storage
+        this.chatHistory = this.storage.get('chat_history') || [];
+
+        // Initialize AI provider
+        this.aiProvider = AIProviderFactory.create(
+            this.config.provider,
+            this.config.apiKey,
+            this.config.model,
+            this.config.proxyUrl
+        );
+
+        // Initialize Firebase analytics (if enabled)
+        if (this.config.analytics.enabled) {
+            this.analytics = new FirebaseLogger(this.config.analytics);
+        }
+
+        // Create and render the chat widget
+        this.widget = new ChatWidget({
+            ...this.config,
+            onSendMessage: (message) => this._handleUserMessage(message),
+            onClearHistory: () => this._clearHistory(),
+            chatHistory: this.chatHistory
+        });
+
+        this.widget.render();
+
+        this.isInitialized = true;
+        this.events.emit('ready');
+
+        if (this.config.onReady) {
+            this.config.onReady();
+        }
+
+        console.log(`[AskJunkie] SDK v${AskJunkie.VERSION} initialized successfully`);
+    }
+
+    /**
+     * Merge user config with defaults
+     */
+    _mergeConfig(userConfig) {
+        const defaults = {
+            // Required
+            apiKey: null,
+
+            // Master enable flag
+            enabled: true,
+
+            // AI Provider
+            provider: 'groq',
+            model: null, // Will use provider default
+
+            // Appearance
+            botName: 'AI Assistant',
+            botAvatar: null, // URL to custom avatar
+            welcomeMessage: "Hi! 👋 I'm your AI assistant. How can I help you today?",
+            position: 'bottom-right',
+            theme: {
+                mode: 'gradient',
+                preset: 1,
+                primary: '#6366f1',
+                secondary: '#ec4899'
+            },
+
+            // Behavior
+            draggable: false,
+            resizable: false,
+            persistChat: true,
+            voiceInput: true,
+            suggestions: [],
+            animatedSuggestions: true,
+            openOnLoad: false,
+
+            // Context for AI
+            context: {
+                siteName: document.title || 'Website',
+                siteDescription: '',
+                customInfo: '',
+                restrictions: ''
+            },
+
+            // Analytics
+            analytics: {
+                enabled: true,
+                siteId: window.location.hostname.replace(/[^a-zA-Z0-9.-]/g, '_')
+            },
+
+            // Proxy mode (optional)
+            proxyUrl: null,
+
+            // Storage prefix
+            storagePrefix: 'ask_junkie_',
+
+            // Event callbacks
+            onReady: null,
+            onMessage: null,
+            onOpen: null,
+            onClose: null,
+            onError: null
+        };
+
+        // Deep merge theme object
+        const theme = { ...defaults.theme, ...(userConfig.theme || {}) };
+        const context = { ...defaults.context, ...(userConfig.context || {}) };
+        const analytics = { ...defaults.analytics, ...(userConfig.analytics || {}) };
+
+        return {
+            ...defaults,
+            ...userConfig,
+            theme,
+            context,
+            analytics
+        };
+    }
+
+    /**
+     * Handle user message submission
+     */
+    async _handleUserMessage(message) {
+        if (!message.trim()) return;
+
+        // Add user message to history
+        this.chatHistory.push({
+            role: 'user',
+            content: message,
+            timestamp: new Date().toISOString()
+        });
+
+        // Show typing indicator
+        this.widget.showTyping();
+
+        try {
+            // Build context string
+            const contextString = this._buildContext();
+
+            // Get AI response
+            const response = await this.aiProvider.sendMessage(
+                message,
+                contextString,
+                this.chatHistory.slice(-10) // Send last 10 messages for context
+            );
+
+            // Add bot response to history
+            this.chatHistory.push({
+                role: 'assistant',
+                content: response,
+                timestamp: new Date().toISOString()
+            });
+
+            // Display response
+            this.widget.hideTyping();
+            this.widget.addMessage(response, 'bot');
+
+            // Save to storage
+            if (this.config.persistChat) {
+                this.storage.set('chat_history', this.chatHistory.slice(-50));
+            }
+
+            // Log to analytics
+            if (this.analytics) {
+                this.analytics.logChat({
+                    userMessage: message,
+                    aiResponse: response,
+                    pageUrl: window.location.href,
+                    sessionId: this.storage.getSessionId()
+                });
+            }
+
+            // Fire callback
+            if (this.config.onMessage) {
+                this.config.onMessage(response, true);
+            }
+
+            this.events.emit('message', { message: response, isBot: true });
+
+        } catch (error) {
+            this.widget.hideTyping();
+            const errorMessage = 'Sorry, I encountered an error. Please try again.';
+            this.widget.addMessage(errorMessage, 'bot');
+
+            console.error('[AskJunkie] Error:', error);
+
+            if (this.config.onError) {
+                this.config.onError(error);
+            }
+
+            this.events.emit('error', error);
+        }
+    }
+
+    /**
+     * Build AI context from configuration
+     */
+    _buildContext() {
+        const ctx = this.config.context;
+        let context = '';
+
+        context += `You are "${this.config.botName}", a friendly and helpful AI assistant for "${ctx.siteName}". `;
+        context += `Your personality is warm, professional, and knowledgeable. `;
+
+        context += `IMPORTANT IDENTITY RULES: `;
+        context += `1. Your name is ${this.config.botName}. `;
+        context += `2. If asked who created you, politely say you're an AI assistant designed to help with website inquiries. `;
+        context += `3. Stay focused on helping users with questions about this website. `;
+
+        if (ctx.siteDescription) {
+            context += `\n\nABOUT THIS WEBSITE: ${ctx.siteDescription} `;
+        }
+
+        if (ctx.customInfo) {
+            context += `\n\nADDITIONAL INFORMATION: ${ctx.customInfo} `;
+        }
+
+        if (ctx.restrictions) {
+            context += `\n\n🚫 RESTRICTIONS (follow strictly): ${ctx.restrictions} `;
+        }
+
+        context += `\n\nRESPONSE FORMATTING: `;
+        context += `1. Be professional and courteous. `;
+        context += `2. Use clear paragraphs with line breaks. `;
+        context += `3. For lists, use numbered points or bullets. `;
+        context += `4. For links, use markdown format: [Link Text](URL). `;
+        context += `5. Use **bold** for important terms. `;
+        context += `6. Keep responses helpful but concise. `;
+
+        return context;
+    }
+
+    /**
+     * Clear chat history
+     */
+    _clearHistory() {
+        this.chatHistory = [];
+        this.storage.remove('chat_history');
+        this.events.emit('clear');
+    }
+
+    // ===== PUBLIC API =====
+
+    /**
+     * Open the chat widget
+     */
+    static open() {
+        if (AskJunkie.instance?.widget) {
+            AskJunkie.instance.widget.open();
+        }
+    }
+
+    /**
+     * Close the chat widget
+     */
+    static close() {
+        if (AskJunkie.instance?.widget) {
+            AskJunkie.instance.widget.close();
+        }
+    }
+
+    /**
+     * Toggle the chat widget
+     */
+    static toggle() {
+        if (AskJunkie.instance?.widget) {
+            AskJunkie.instance.widget.toggle();
+        }
+    }
+
+    /**
+     * Send a message programmatically
+     */
+    static sendMessage(text) {
+        if (AskJunkie.instance) {
+            AskJunkie.instance.widget.addMessage(text, 'user');
+            AskJunkie.instance._handleUserMessage(text);
+        }
+    }
+
+    /**
+     * Update context dynamically
+     */
+    static setContext(newContext) {
+        if (AskJunkie.instance) {
+            AskJunkie.instance.config.context = {
+                ...AskJunkie.instance.config.context,
+                ...newContext
+            };
+        }
+    }
+
+    /**
+     * Subscribe to events
+     */
+    static on(event, callback) {
+        if (AskJunkie.instance) {
+            AskJunkie.instance.events.on(event, callback);
+        }
+    }
+
+    /**
+     * Destroy the SDK instance
+     */
+    static destroy() {
+        if (AskJunkie.instance) {
+            if (AskJunkie.instance.widget) {
+                AskJunkie.instance.widget.destroy();
+            }
+            AskJunkie.instance.isInitialized = false;
+            AskJunkie.instance = null;
+            console.log('[AskJunkie] Destroyed');
+        }
+    }
+
+    /**
+     * Get SDK version
+     */
+    static getVersion() {
+        return AskJunkie.VERSION;
+    }
+}
+
+export default AskJunkie;

package/src/core/EventEmitter.js

@@ -0,0 +1,52 @@
+/**
+ * Simple Event Emitter for SDK events
+ */
+
+export class EventEmitter {
+    constructor() {
+        this.events = {};
+    }
+
+    /**
+     * Subscribe to an event
+     */
+    on(event, callback) {
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        this.events[event].push(callback);
+        return () => this.off(event, callback);
+    }
+
+    /**
+     * Unsubscribe from an event
+     */
+    off(event, callback) {
+        if (!this.events[event]) return;
+        this.events[event] = this.events[event].filter(cb => cb !== callback);
+    }
+
+    /**
+     * Emit an event
+     */
+    emit(event, data) {
+        if (!this.events[event]) return;
+        this.events[event].forEach(callback => {
+            try {
+                callback(data);
+            } catch (error) {
+                console.error(`[AskJunkie] Event handler error for "${event}":`, error);
+            }
+        });
+    }
+
+    /**
+     * Subscribe to an event once
+     */
+    once(event, callback) {
+        const unsubscribe = this.on(event, (data) => {
+            unsubscribe();
+            callback(data);
+        });
+    }
+}

package/src/index.js

@@ -0,0 +1,19 @@
+/**
+ * Ask Junkie SDK - Main Entry Point
+ * Universal AI Chatbot for any website
+ * 
+ * @author Junkies Coder
+ * @version 1.0.0
+ */
+
+import AskJunkie from './core/AskJunkie.js';
+import './ui/styles.css';
+
+// Export for ES modules
+export default AskJunkie;
+export { AskJunkie };
+
+// Auto-attach to window for script tag usage
+if (typeof window !== 'undefined') {
+    window.AskJunkie = AskJunkie;
+}