@courseecho/ai-widget-react 1.0.23 → 1.0.24

package/dist/core/src/auto-suggestion-generator.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Page Content Scanner and AI Suggestion Generator
+ * Automatically extracts page content and generates AI-powered suggestions
+ */
+import { AiSuggestion, PageScanConfig, AiSuggestionGeneratorConfig } from './models';
+export interface PageContent {
+    url: string;
+    title: string;
+    description: string;
+    headings: string[];
+    keywords: string[];
+    pageType: string;
+    rawText: string;
+}
+/**
+ * Scans page content and extracts relevant information
+ */
+export declare class PageContentScanner {
+    private config;
+    private cachedContent;
+    constructor(config?: PageScanConfig);
+    /**
+     * Scan page content
+     */
+    scanPage(): PageContent;
+    /**
+     * Get cached content if still valid
+     */
+    private getCachedContent;
+    /**
+     * Cache content
+     */
+    private cacheContent;
+    /**
+     * Extract page title
+     */
+    private extractTitle;
+    /**
+     * Extract meta description
+     */
+    private extractDescription;
+    /**
+     * Extract all headings
+     */
+    private extractHeadings;
+    /**
+     * Extract keywords from meta tags
+     */
+    private extractKeywords;
+    /**
+     * Detect page type (course, product, blog, etc.)
+     */
+    private detectPageType;
+    /**
+     * Extract main text content
+     */
+    private extractMainContent;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Update config
+     */
+    updateConfig(config: Partial<PageScanConfig>): void;
+}
+/**
+ * Generates AI-powered suggestions based on page content
+ */
+export declare class AiSuggestionGenerator {
+    private config;
+    private pageScanner;
+    constructor(config?: AiSuggestionGeneratorConfig, pageScanner?: PageContentScanner);
+    /**
+     * Generate suggestions based on page content
+     */
+    generateSuggestions(): Promise<AiSuggestion[]>;
+    /**
+     * Free tier: Generate suggestions locally based on heuristics
+     */
+    private generateFreeSuggestions;
+    /**
+     * Premium tier: Use backend AI for smart suggestions
+     */
+    private generatePremiumSuggestions;
+    /**
+     * Course page suggestions
+     */
+    private generateCourseSuggestions;
+    /**
+     * Product page suggestions
+     */
+    private generateProductSuggestions;
+    /**
+     * Blog page suggestions
+     */
+    private generateBlogSuggestions;
+    /**
+     * Support page suggestions
+     */
+    private generateSupportSuggestions;
+    /**
+     * Documentation page suggestions
+     */
+    private generateDocsSuggestions;
+    /**
+     * Generic page suggestions
+     */
+    private generateGenericSuggestions;
+    /**
+     * Update config
+     */
+    updateConfig(config: Partial<AiSuggestionGeneratorConfig>): void;
+    /**
+     * Get current tier
+     */
+    getTier(): string;
+}

package/dist/core/src/auto-suggestion-generator.js

@@ -0,0 +1,538 @@
+/**
+ * Page Content Scanner and AI Suggestion Generator
+ * Automatically extracts page content and generates AI-powered suggestions
+ */
+/**
+ * Scans page content and extracts relevant information
+ */
+export class PageContentScanner {
+    constructor(config) {
+        this.cachedContent = new Map();
+        this.config = {
+            enabled: true,
+            autoScan: true,
+            maxTextLength: 5000,
+            cacheDuration: 5 * 60 * 1000, // 5 minutes
+            mergeWithUserSuggestions: true,
+            ...config,
+        };
+    }
+    /**
+     * Scan page content
+     */
+    scanPage() {
+        const url = window.location.href;
+        // Check cache first
+        const cached = this.getCachedContent(url);
+        if (cached) {
+            return cached;
+        }
+        const content = {
+            url,
+            title: this.extractTitle(),
+            description: this.extractDescription(),
+            headings: this.extractHeadings(),
+            keywords: this.extractKeywords(),
+            pageType: this.detectPageType(),
+            rawText: this.extractMainContent(),
+        };
+        // Cache the content
+        this.cacheContent(url, content);
+        return content;
+    }
+    /**
+     * Get cached content if still valid
+     */
+    getCachedContent(url) {
+        const cached = this.cachedContent.get(url);
+        if (!cached) {
+            return null;
+        }
+        if (this.config.cacheDuration && Date.now() - cached.timestamp > this.config.cacheDuration) {
+            this.cachedContent.delete(url);
+            return null;
+        }
+        return cached.content;
+    }
+    /**
+     * Cache content
+     */
+    cacheContent(url, content) {
+        this.cachedContent.set(url, {
+            content,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Extract page title
+     */
+    extractTitle() {
+        const titleTag = document.querySelector('title');
+        if (titleTag) {
+            return titleTag.textContent || '';
+        }
+        const h1 = document.querySelector('h1');
+        if (h1) {
+            return h1.textContent || '';
+        }
+        return document.title || 'Untitled Page';
+    }
+    /**
+     * Extract meta description
+     */
+    extractDescription() {
+        const metaDesc = document.querySelector('meta[name="description"]');
+        if (metaDesc) {
+            return metaDesc.getAttribute('content') || '';
+        }
+        const metaOgDesc = document.querySelector('meta[property="og:description"]');
+        if (metaOgDesc) {
+            return metaOgDesc.getAttribute('content') || '';
+        }
+        // Fallback: use first paragraph
+        const firstP = document.querySelector('p');
+        if (firstP) {
+            return firstP.textContent?.slice(0, 160) || '';
+        }
+        return '';
+    }
+    /**
+     * Extract all headings
+     */
+    extractHeadings() {
+        const headings = Array.from(document.querySelectorAll('h1, h2, h3, h4, h5, h6'));
+        return headings
+            .map((h) => h.textContent || '')
+            .filter((text) => text.length > 0)
+            .slice(0, 20); // Limit to 20 headings
+    }
+    /**
+     * Extract keywords from meta tags
+     */
+    extractKeywords() {
+        const keywordsMeta = document.querySelector('meta[name="keywords"]');
+        if (keywordsMeta) {
+            const content = keywordsMeta.getAttribute('content') || '';
+            return content.split(',').map((k) => k.trim());
+        }
+        // Generate keywords from headings and title
+        const headings = this.extractHeadings();
+        return headings.slice(0, 10);
+    }
+    /**
+     * Detect page type (course, product, blog, etc.)
+     */
+    detectPageType() {
+        const url = window.location.pathname.toLowerCase();
+        const content = document.body.innerText.toLowerCase();
+        if (url.includes('course') || content.includes('learning objectives')) {
+            return 'course';
+        }
+        if (url.includes('product') || url.includes('shop')) {
+            return 'product';
+        }
+        if (url.includes('blog') || url.includes('article')) {
+            return 'blog';
+        }
+        if (url.includes('support') || url.includes('help') || url.includes('faq')) {
+            return 'support';
+        }
+        if (url.includes('docs') || url.includes('documentation')) {
+            return 'documentation';
+        }
+        return 'generic';
+    }
+    /**
+     * Extract main text content
+     */
+    extractMainContent() {
+        // Remove script, style, and excluded elements
+        const clone = document.body.cloneNode(true);
+        // Remove unwanted elements
+        const toRemove = clone.querySelectorAll('script, style, nav, footer, .ads, .sidebar');
+        toRemove.forEach((el) => el.remove());
+        // Apply custom selectors if provided
+        if (this.config.excludeSelectors) {
+            this.config.excludeSelectors.forEach((selector) => {
+                clone.querySelectorAll(selector).forEach((el) => el.remove());
+            });
+        }
+        let text = clone.innerText || clone.textContent || '';
+        // Clean up whitespace
+        text = text
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .join(' ');
+        // Truncate to max length
+        if (this.config.maxTextLength && text.length > this.config.maxTextLength) {
+            text = text.slice(0, this.config.maxTextLength) + '...';
+        }
+        return text;
+    }
+    /**
+     * Clear cache
+     */
+    clearCache() {
+        this.cachedContent.clear();
+    }
+    /**
+     * Update config
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+}
+/**
+ * Generates AI-powered suggestions based on page content
+ */
+export class AiSuggestionGenerator {
+    constructor(config, pageScanner) {
+        this.config = {
+            enabled: true,
+            tier: 'free',
+            timeoutMs: 5000,
+            ...config,
+        };
+        this.pageScanner = pageScanner || new PageContentScanner();
+    }
+    /**
+     * Generate suggestions based on page content
+     */
+    async generateSuggestions() {
+        if (!this.config.enabled) {
+            return [];
+        }
+        // Check tier (free gets limited suggestions)
+        if (this.config.tier === 'free') {
+            return this.generateFreeSuggestions();
+        }
+        // Premium tier: use backend AI
+        return this.generatePremiumSuggestions();
+    }
+    /**
+     * Free tier: Generate suggestions locally based on heuristics
+     */
+    generateFreeSuggestions() {
+        const pageContent = this.pageScanner.scanPage();
+        const suggestions = [];
+        // Generate suggestions based on page type
+        switch (pageContent.pageType) {
+            case 'course':
+                suggestions.push(...this.generateCourseSuggestions(pageContent));
+                break;
+            case 'product':
+                suggestions.push(...this.generateProductSuggestions(pageContent));
+                break;
+            case 'blog':
+                suggestions.push(...this.generateBlogSuggestions(pageContent));
+                break;
+            case 'support':
+                suggestions.push(...this.generateSupportSuggestions(pageContent));
+                break;
+            case 'documentation':
+                suggestions.push(...this.generateDocsSuggestions(pageContent));
+                break;
+            default:
+                suggestions.push(...this.generateGenericSuggestions(pageContent));
+        }
+        return suggestions;
+    }
+    /**
+     * Premium tier: Use backend AI for smart suggestions
+     */
+    async generatePremiumSuggestions() {
+        if (!this.config.backendUrl) {
+            console.warn('Backend URL not configured. Falling back to free tier.');
+            return this.generateFreeSuggestions();
+        }
+        try {
+            const pageContent = this.pageScanner.scanPage();
+            const response = await fetch(`${this.config.backendUrl}/api/suggestions/generate`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(this.config.apiKey && { 'X-API-Key': this.config.apiKey }),
+                },
+                body: JSON.stringify({
+                    pageContent,
+                    tier: this.config.tier,
+                }),
+                signal: AbortSignal.timeout(this.config.timeoutMs || 5000),
+            });
+            if (!response.ok) {
+                throw new Error(`API error: ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            console.error('Error generating premium suggestions:', error);
+            // Fallback to free tier
+            return this.generateFreeSuggestions();
+        }
+    }
+    /**
+     * Course page suggestions
+     */
+    generateCourseSuggestions(pageContent) {
+        return [
+            {
+                id: `auto-course-1-${Date.now()}`,
+                text: 'What are the learning objectives?',
+                icon: '📚',
+                category: 'Course',
+                description: 'Understand course goals and objectives',
+            },
+            {
+                id: `auto-course-2-${Date.now()}`,
+                text: 'How do I submit assignments?',
+                icon: '📝',
+                category: 'Assignments',
+                description: 'Learn how to complete and submit work',
+            },
+            {
+                id: `auto-course-3-${Date.now()}`,
+                text: 'What resources are available?',
+                icon: '🔍',
+                category: 'Resources',
+                description: 'Find course materials and references',
+            },
+            {
+                id: `auto-course-4-${Date.now()}`,
+                text: 'How is this course graded?',
+                icon: '📊',
+                category: 'Grading',
+                description: 'Review grading criteria and rubrics',
+            },
+            {
+                id: `auto-course-5-${Date.now()}`,
+                text: 'Who is the instructor?',
+                icon: '👨‍🏫',
+                category: 'Instructor',
+                description: 'Learn about the course instructor',
+            },
+        ];
+    }
+    /**
+     * Product page suggestions
+     */
+    generateProductSuggestions(pageContent) {
+        return [
+            {
+                id: `auto-product-1-${Date.now()}`,
+                text: 'What are the product specifications?',
+                icon: '⚙️',
+                category: 'Details',
+                description: 'View detailed product specs',
+            },
+            {
+                id: `auto-product-2-${Date.now()}`,
+                text: 'How much does this cost?',
+                icon: '💰',
+                category: 'Pricing',
+                description: 'See pricing and available plans',
+            },
+            {
+                id: `auto-product-3-${Date.now()}`,
+                text: 'What shipping options are available?',
+                icon: '🚚',
+                category: 'Shipping',
+                description: 'Check delivery options',
+            },
+            {
+                id: `auto-product-4-${Date.now()}`,
+                text: 'What is your return policy?',
+                icon: '↩️',
+                category: 'Returns',
+                description: 'Learn about returns and refunds',
+            },
+            {
+                id: `auto-product-5-${Date.now()}`,
+                text: 'Do you have customer reviews?',
+                icon: '⭐',
+                category: 'Reviews',
+                description: 'See what customers think',
+            },
+        ];
+    }
+    /**
+     * Blog page suggestions
+     */
+    generateBlogSuggestions(pageContent) {
+        return [
+            {
+                id: `auto-blog-1-${Date.now()}`,
+                text: 'What is this article about?',
+                icon: '📖',
+                category: 'Content',
+                description: 'Get summary of the article',
+            },
+            {
+                id: `auto-blog-2-${Date.now()}`,
+                text: 'Can you expand on this topic?',
+                icon: '💭',
+                category: 'Discussion',
+                description: 'Dive deeper into the subject',
+            },
+            {
+                id: `auto-blog-3-${Date.now()}`,
+                text: 'Related articles and resources?',
+                icon: '🔗',
+                category: 'Links',
+                description: 'Find related content',
+            },
+            {
+                id: `auto-blog-4-${Date.now()}`,
+                text: 'Who is the author?',
+                icon: '✍️',
+                category: 'Author',
+                description: 'Learn about the writer',
+            },
+            {
+                id: `auto-blog-5-${Date.now()}`,
+                text: 'When was this published?',
+                icon: '📅',
+                category: 'Date',
+                description: 'Check publication date',
+            },
+        ];
+    }
+    /**
+     * Support page suggestions
+     */
+    generateSupportSuggestions(pageContent) {
+        return [
+            {
+                id: `auto-support-1-${Date.now()}`,
+                text: 'How do I reset my password?',
+                icon: '🔐',
+                category: 'Account',
+                description: 'Password recovery help',
+            },
+            {
+                id: `auto-support-2-${Date.now()}`,
+                text: 'How do I contact support?',
+                icon: '📞',
+                category: 'Support',
+                description: 'Get in touch with support',
+            },
+            {
+                id: `auto-support-3-${Date.now()}`,
+                text: 'What are my billing options?',
+                icon: '💳',
+                category: 'Billing',
+                description: 'Payment information',
+            },
+            {
+                id: `auto-support-4-${Date.now()}`,
+                text: 'How do I cancel my subscription?',
+                icon: '❌',
+                category: 'Subscription',
+                description: 'Manage subscription',
+            },
+            {
+                id: `auto-support-5-${Date.now()}`,
+                text: 'What are my rights?',
+                icon: '⚖️',
+                category: 'Legal',
+                description: 'View terms and conditions',
+            },
+        ];
+    }
+    /**
+     * Documentation page suggestions
+     */
+    generateDocsSuggestions(pageContent) {
+        return [
+            {
+                id: `auto-docs-1-${Date.now()}`,
+                text: 'How do I get started?',
+                icon: '🚀',
+                category: 'Getting Started',
+                description: 'Quick start guide',
+            },
+            {
+                id: `auto-docs-2-${Date.now()}`,
+                text: 'What are the system requirements?',
+                icon: '⚙️',
+                category: 'Requirements',
+                description: 'Technical specifications',
+            },
+            {
+                id: `auto-docs-3-${Date.now()}`,
+                text: 'Do you have code examples?',
+                icon: '💻',
+                category: 'Examples',
+                description: 'View code samples',
+            },
+            {
+                id: `auto-docs-4-${Date.now()}`,
+                text: 'How is this documented?',
+                icon: '📚',
+                category: 'Docs',
+                description: 'Browse all documentation',
+            },
+            {
+                id: `auto-docs-5-${Date.now()}`,
+                text: 'How do I report issues?',
+                icon: '🐛',
+                category: 'Issues',
+                description: 'Report bugs and issues',
+            },
+        ];
+    }
+    /**
+     * Generic page suggestions
+     */
+    generateGenericSuggestions(pageContent) {
+        return [
+            {
+                id: `auto-generic-1-${Date.now()}`,
+                text: 'Tell me more about this topic',
+                icon: '❓',
+                category: 'General',
+                description: 'Get more information',
+            },
+            {
+                id: `auto-generic-2-${Date.now()}`,
+                text: 'What are the key points?',
+                icon: '📍',
+                category: 'Summary',
+                description: 'See main highlights',
+            },
+            {
+                id: `auto-generic-3-${Date.now()}`,
+                text: 'How can I use this?',
+                icon: '💡',
+                category: 'Usage',
+                description: 'Learn how to use this',
+            },
+            {
+                id: `auto-generic-4-${Date.now()}`,
+                text: 'Where can I learn more?',
+                icon: '🔗',
+                category: 'Resources',
+                description: 'Find additional resources',
+            },
+            {
+                id: `auto-generic-5-${Date.now()}`,
+                text: 'How do I get help?',
+                icon: '🤝',
+                category: 'Help',
+                description: 'Get support',
+            },
+        ];
+    }
+    /**
+     * Update config
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Get current tier
+     */
+    getTier() {
+        return this.config.tier || 'free';
+    }
+}

package/dist/core/src/communication-service.d.ts

@@ -0,0 +1,47 @@
+/**
+ * AI Widget SDK - Core Communication Service
+ * Handle HTTP requests to backend API
+ */
+import { AiQueryRequest, AiQueryResponse } from './models';
+export declare class AiCommunicationService {
+    private apiEndpoint;
+    private apiKey?;
+    private jwtToken?;
+    constructor(apiEndpoint: string, apiKey?: string);
+    /**
+     * Set JWT token for authentication
+     */
+    setJwtToken(token: string): void;
+    /**
+     * Get current JWT token
+     */
+    getJwtToken(): string | undefined;
+    /**
+     * Check if JWT token is set
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Send query to backend API
+     */
+    sendQuery(request: AiQueryRequest): Promise<AiQueryResponse>;
+    /**
+     * Check backend health
+     */
+    checkHealth(): Promise<boolean>;
+    /**
+     * Get API endpoint
+     */
+    getApiEndpoint(): string;
+}
+/**
+ * Custom API Error class
+ */
+export declare class ApiError extends Error {
+    statusCode: number;
+    responseData?: any | undefined;
+    constructor(message: string, statusCode: number, responseData?: any | undefined);
+    isRateLimited(): boolean;
+    isUnauthorized(): boolean;
+    isBadRequest(): boolean;
+    isServerError(): boolean;
+}