@courseecho/ai-widget-react 1.0.24 → 1.0.25

package/dist/core/src/sdk.js

@@ -1,387 +0,0 @@
-/**
- * AI Widget SDK - Core SDK
- * Main orchestrator that ties everything together
- */
-import { AiCommunicationService, ApiError } from './communication-service';
-import { ChatStateManager, ContextStateManager, ChartManager, SuggestionManager, } from './state-manager';
-import { PageContentScanner, AiSuggestionGenerator, } from './auto-suggestion-generator';
-export class AiWidgetSDK {
-    constructor(config) {
-        this.validateConfig(config);
-        this.config = { apiEndpoint: 'https://ai.courseecho.com', ...config };
-        // Initialize services
-        this.communicationService = new AiCommunicationService(this.config.apiEndpoint, this.config.apiKey);
-        this.chatStateManager = new ChatStateManager(config.maxChatHistory ?? 100);
-        this.contextStateManager = new ContextStateManager(config.context);
-        this.chartManager = new ChartManager();
-        this.suggestionManager = new SuggestionManager(config.suggestionConfig);
-        // Initialize auto-suggestion components
-        this.pageContentScanner = new PageContentScanner(config.suggestionConfig?.pageScanning);
-        this.suggestionGenerator = new AiSuggestionGenerator(config.suggestionConfig?.aiConfig, this.pageContentScanner);
-        // Initialize auto-suggestions if enabled
-        this.initializeAutoSuggestions();
-    }
-    /**
-     * Initialize auto-suggestions based on page content
-     */
-    async initializeAutoSuggestions() {
-        const suggestionConfig = this.config.suggestionConfig;
-        // Check if auto-generation is enabled
-        if (!suggestionConfig?.autoGenerate) {
-            return;
-        }
-        // Check tier: free tier gets suggestions automatically
-        if (suggestionConfig.autoGenerateFreeTier !== false) {
-            try {
-                const autoSuggestions = await this.suggestionGenerator.generateSuggestions();
-                // Merge with user-provided suggestions if configured
-                if (suggestionConfig.pageScanning?.mergeWithUserSuggestions !== false) {
-                    const existingSuggestions = this.suggestionManager.getSuggestions();
-                    this.suggestionManager.addSuggestions(autoSuggestions);
-                }
-                else {
-                    // Replace with auto-generated suggestions
-                    this.suggestionManager.clearSuggestions();
-                    this.suggestionManager.addSuggestions(autoSuggestions);
-                }
-            }
-            catch (error) {
-                console.error('Error generating auto-suggestions:', error);
-            }
-        }
-        // Set up periodic re-scanning if configured
-        if (suggestionConfig.pageScanning?.autoScan) {
-            const scanInterval = suggestionConfig.pageScanning.scanInterval || 60000; // 60 seconds default
-            this.autoSuggestionInterval = setInterval(async () => {
-                try {
-                    const freshSuggestions = await this.suggestionGenerator.generateSuggestions();
-                    if (suggestionConfig.pageScanning?.mergeWithUserSuggestions === false) {
-                        this.suggestionManager.clearSuggestions();
-                    }
-                    this.suggestionManager.addSuggestions(freshSuggestions);
-                }
-                catch (error) {
-                    console.error('Error refreshing auto-suggestions:', error);
-                }
-            }, scanInterval);
-        }
-    }
-    /**
-     * Validate configuration
-     */
-    validateConfig(config) {
-        if (!config.context) {
-            throw new Error('context is required in config');
-        }
-    }
-    /**
-     * Set JWT token for authentication
-     */
-    setJwtToken(token) {
-        this.communicationService.setJwtToken(token);
-    }
-    /**
-     * Send a query to the AI backend
-     */
-    async sendQuery(userQuery) {
-        try {
-            this.chatStateManager.setLoading(true);
-            this.chatStateManager.setError(null);
-            // Add user message to chat
-            const userMessage = {
-                id: this.generateId(),
-                role: 'user',
-                content: userQuery,
-                timestamp: new Date(),
-            };
-            this.chatStateManager.addMessage(userMessage);
-            // Prepare request
-            const request = {
-                userQuery,
-                pageType: this.contextStateManager.getContext().pageType,
-                entityId: this.contextStateManager.getContext().entityId,
-                contextData: this.contextStateManager.getContext().customData,
-            };
-            // Send to backend
-            const response = await this.communicationService.sendQuery(request);
-            // Add assistant message
-            const assistantMessage = {
-                id: response.sessionId,
-                role: 'assistant',
-                content: response.response,
-                timestamp: response.timestamp,
-                metadata: {
-                    hasChart: false,
-                    charts: [],
-                    suggestedFollowUps: [],
-                },
-            };
-            // Cache charts if any
-            if (assistantMessage.metadata?.charts && assistantMessage.metadata.charts.length > 0) {
-                assistantMessage.metadata.hasChart = true;
-                assistantMessage.metadata.charts.forEach((chart, index) => {
-                    this.chartManager.cacheChart(`${response.sessionId}_${index}`, chart);
-                });
-            }
-            this.chatStateManager.addMessage(assistantMessage);
-            return assistantMessage;
-        }
-        catch (error) {
-            const errorMessage = this.getErrorMessage(error);
-            this.chatStateManager.setError(errorMessage);
-            throw error;
-        }
-        finally {
-            this.chatStateManager.setLoading(false);
-        }
-    }
-    /**
-     * Update context
-     */
-    setContext(context) {
-        const currentContext = this.contextStateManager.getContext();
-        this.contextStateManager.setContext({
-            ...currentContext,
-            ...context,
-        });
-    }
-    /**
-     * Update single context property
-     */
-    updateContextProperty(key, value) {
-        this.contextStateManager.updateProperty(key, value);
-    }
-    /**
-     * Get current context
-     */
-    getContext() {
-        return this.contextStateManager.getContext();
-    }
-    /**
-     * Clear chat history
-     */
-    clearChatHistory() {
-        this.chatStateManager.clearMessages();
-        this.chartManager.clearCache();
-    }
-    /**
-     * Get chat messages
-     */
-    getMessages() {
-        return this.chatStateManager.getMessages();
-    }
-    /**
-     * Get current error
-     */
-    getError() {
-        return this.chatStateManager.getError();
-    }
-    /**
-     * Check if loading
-     */
-    isLoading() {
-        return this.chatStateManager.isLoadingState();
-    }
-    /**
-     * Export chat history
-     */
-    exportChats(format = 'json') {
-        const messages = this.getMessages();
-        if (format === 'json') {
-            return JSON.stringify({
-                context: this.getContext(),
-                messages,
-                exportedAt: new Date(),
-            }, null, 2);
-        }
-        else {
-            const headers = ['Timestamp', 'Role', 'Content'];
-            const rows = [headers.join(',')];
-            messages.forEach((msg) => {
-                const row = [
-                    new Date(msg.timestamp).toISOString(),
-                    msg.role,
-                    `"${msg.content.replace(/"/g, '""')}"`, // Escape quotes
-                ];
-                rows.push(row.join(','));
-            });
-            return rows.join('\n');
-        }
-    }
-    /**
-     * Export charts
-     */
-    exportCharts(format = 'json') {
-        if (format === 'json') {
-            return this.chartManager.exportToJSON();
-        }
-        else {
-            return this.chartManager.exportToCSV();
-        }
-    }
-    /**
-     * Check backend health
-     */
-    async checkHealth() {
-        return this.communicationService.checkHealth();
-    }
-    /**
-     * Subscribe to message changes
-     */
-    onMessagesChange(listener) {
-        return this.chatStateManager.onMessagesChange(listener);
-    }
-    /**
-     * Subscribe to loading changes
-     */
-    onLoadingChange(listener) {
-        return this.chatStateManager.onLoadingChange(listener);
-    }
-    /**
-     * Subscribe to error changes
-     */
-    onErrorChange(listener) {
-        return this.chatStateManager.onErrorChange(listener);
-    }
-    /**
-     * Subscribe to context changes
-     */
-    onContextChange(listener) {
-        return this.contextStateManager.onContextChange(listener);
-    }
-    /**
-     * Get all suggestions
-     */
-    getSuggestions() {
-        return this.suggestionManager.getSuggestions();
-    }
-    /**
-     * Filter suggestions based on query
-     */
-    filterSuggestions(query) {
-        return this.suggestionManager.filterSuggestions(query);
-    }
-    /**
-     * Get suggestions by category
-     */
-    getSuggestionsByCategory(category) {
-        return this.suggestionManager.getSuggestionsByCategory(category);
-    }
-    /**
-     * Add a suggestion
-     */
-    addSuggestion(suggestion) {
-        this.suggestionManager.addSuggestion(suggestion);
-    }
-    /**
-     * Add multiple suggestions
-     */
-    addSuggestions(suggestions) {
-        this.suggestionManager.addSuggestions(suggestions);
-    }
-    /**
-     * Remove a suggestion by id
-     */
-    removeSuggestion(id) {
-        this.suggestionManager.removeSuggestion(id);
-    }
-    /**
-     * Clear all suggestions
-     */
-    clearSuggestions() {
-        this.suggestionManager.clearSuggestions();
-    }
-    /**
-     * Update suggestion
-     */
-    updateSuggestion(id, updates) {
-        this.suggestionManager.updateSuggestion(id, updates);
-    }
-    /**
-     * Subscribe to suggestion changes
-     */
-    onSuggestionsChange(listener) {
-        return this.suggestionManager.onSuggestionsChange(listener);
-    }
-    /**
-     * Get suggestion manager for advanced use
-     */
-    getSuggestionManager() {
-        return this.suggestionManager;
-    }
-    /**
-     * Get internal services (for advanced use)
-     */
-    getServices() {
-        return {
-            communication: this.communicationService,
-            chatState: this.chatStateManager,
-            contextState: this.contextStateManager,
-            charts: this.chartManager,
-            suggestions: this.suggestionManager,
-        };
-    }
-    /**
-     * Trigger manual page scan for auto-suggestions
-     */
-    async triggerAutoSuggestions() {
-        try {
-            const suggestions = await this.suggestionGenerator.generateSuggestions();
-            if (this.config.suggestionConfig?.pageScanning?.mergeWithUserSuggestions === false) {
-                this.suggestionManager.clearSuggestions();
-            }
-            this.suggestionManager.addSuggestions(suggestions);
-        }
-        catch (error) {
-            console.error('Error triggering auto-suggestions:', error);
-        }
-    }
-    /**
-     * Get page content scanner
-     */
-    getPageContentScanner() {
-        return this.pageContentScanner;
-    }
-    /**
-     * Get suggestion generator
-     */
-    getSuggestionGenerator() {
-        return this.suggestionGenerator;
-    }
-    /**
-     * Stop auto-suggestion scanning
-     */
-    stopAutoSuggestions() {
-        if (this.autoSuggestionInterval) {
-            clearInterval(this.autoSuggestionInterval);
-            this.autoSuggestionInterval = undefined;
-        }
-    }
-    /**
-     * Private helper to generate unique IDs
-     */
-    generateId() {
-        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    /**
-     * Private helper to extract error message
-     */
-    getErrorMessage(error) {
-        if (error instanceof ApiError) {
-            if (error.isRateLimited()) {
-                return 'Too many requests. Please wait before sending more queries.';
-            }
-            if (error.isUnauthorized()) {
-                return 'Authentication failed. Please check your token.';
-            }
-            if (error.isBadRequest()) {
-                return 'Invalid request. Please check your query.';
-            }
-            if (error.isServerError()) {
-                return 'Server error. Please try again later.';
-            }
-            return error.message;
-        }
-        return String(error);
-    }
-}

package/dist/core/src/state-manager.d.ts

@@ -1,200 +0,0 @@
-/**
- * AI Widget SDK - Core Chat State Manager
- * Manage chat messages, loading state, errors - framework-agnostic
- */
-import { AiMessage, AiChart, AiContext, AiSuggestion, SuggestionConfig } from './models';
-export type StateListener<T> = (state: T) => void;
-/**
- * Core Chat State - manages messages and loading states
- */
-export declare class ChatStateManager {
-    private messages;
-    private maxChatHistory;
-    private isLoading;
-    private error;
-    private messageListeners;
-    private loadingListeners;
-    private errorListeners;
-    constructor(maxChatHistory?: number);
-    /**
-     * Add a new message
-     */
-    addMessage(message: AiMessage): void;
-    /**
-     * Get all messages
-     */
-    getMessages(): AiMessage[];
-    /**
-     * Clear all messages
-     */
-    clearMessages(): void;
-    /**
-     * Set loading state
-     */
-    setLoading(isLoading: boolean): void;
-    /**
-     * Get loading state
-     */
-    isLoadingState(): boolean;
-    /**
-     * Set error
-     */
-    setError(error: string | null): void;
-    /**
-     * Get current error
-     */
-    getError(): string | null;
-    /**
-     * Get last message
-     */
-    getLastMessage(): AiMessage | undefined;
-    /**
-     * Get message count
-     */
-    getMessageCount(): number;
-    /**
-     * Subscribe to message changes
-     */
-    onMessagesChange(listener: StateListener<AiMessage[]>): () => void;
-    /**
-     * Subscribe to loading changes
-     */
-    onLoadingChange(listener: StateListener<boolean>): () => void;
-    /**
-     * Subscribe to error changes
-     */
-    onErrorChange(listener: StateListener<string | null>): () => void;
-    private notifyMessageListeners;
-    private notifyLoadingListeners;
-    private notifyErrorListeners;
-}
-/**
- * Core Context State - manages page context
- */
-export declare class ContextStateManager {
-    private context;
-    private contextHistory;
-    private contextListeners;
-    constructor(initialContext: AiContext);
-    /**
-     * Update entire context
-     */
-    setContext(context: AiContext): void;
-    /**
-     * Update single context property
-     */
-    updateProperty(key: string, value: any): void;
-    /**
-     * Get current context
-     */
-    getContext(): AiContext;
-    /**
-     * Get context history
-     */
-    getHistory(): AiContext[];
-    /**
-     * Get single context property
-     */
-    getProperty(key: string): any;
-    /**
-     * Subscribe to context changes
-     */
-    onContextChange(listener: StateListener<AiContext>): () => void;
-    /**
-     * Serialize context
-     */
-    serialize(): string;
-    private notifyContextListeners;
-}
-/**
- * Chart Manager - manage charts caching and export
- */
-export declare class ChartManager {
-    private charts;
-    /**
-     * Cache a chart
-     */
-    cacheChart(id: string, chart: AiChart): void;
-    /**
-     * Get cached chart
-     */
-    getChart(id: string): AiChart | undefined;
-    /**
-     * Get all cached charts
-     */
-    getAllCharts(): AiChart[];
-    /**
-     * Clear cache
-     */
-    clearCache(): void;
-    /**
-     * Export charts to CSV
-     */
-    exportToCSV(filename?: string): string;
-    /**
-     * Export charts to JSON
-     */
-    exportToJSON(): string;
-}
-/**
- * Suggestion Manager - manage suggestions for chat queries
- */
-export declare class SuggestionManager {
-    private suggestions;
-    private config;
-    private suggestionListeners;
-    constructor(config?: SuggestionConfig);
-    /**
-     * Get all suggestions
-     */
-    getSuggestions(): AiSuggestion[];
-    /**
-     * Filter suggestions based on query
-     */
-    filterSuggestions(query: string): AiSuggestion[];
-    /**
-     * Get suggestions by category
-     */
-    getSuggestionsByCategory(category: string): AiSuggestion[];
-    /**
-     * Add a suggestion
-     */
-    addSuggestion(suggestion: AiSuggestion): void;
-    /**
-     * Add multiple suggestions
-     */
-    addSuggestions(suggestions: AiSuggestion[]): void;
-    /**
-     * Remove a suggestion by id
-     */
-    removeSuggestion(id: string): void;
-    /**
-     * Clear all suggestions
-     */
-    clearSuggestions(): void;
-    /**
-     * Update suggestion
-     */
-    updateSuggestion(id: string, updates: Partial<AiSuggestion>): void;
-    /**
-     * Check if suggestions are enabled
-     */
-    isEnabled(): boolean;
-    /**
-     * Toggle suggestions on/off
-     */
-    toggleEnabled(): void;
-    /**
-     * Subscribe to suggestion changes
-     */
-    onSuggestionsChange(listener: StateListener<AiSuggestion[]>): () => void;
-    /**
-     * Get config
-     */
-    getConfig(): SuggestionConfig;
-    /**
-     * Update config
-     */
-    updateConfig(config: Partial<SuggestionConfig>): void;
-    private notifySuggestionListeners;
-}