@courseecho/ai-widget-react 1.0.23 → 1.0.24

package/dist/core/src/communication-service.js

@@ -0,0 +1,124 @@
+/**
+ * AI Widget SDK - Core Communication Service
+ * Handle HTTP requests to backend API
+ */
+/** Safely parse a Response body as JSON — returns null for empty/non-JSON bodies instead of throwing. */
+async function safeJson(res) {
+    const text = await res.text();
+    if (!text || !text.trim())
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export class AiCommunicationService {
+    constructor(apiEndpoint, apiKey) {
+        if (!apiEndpoint) {
+            throw new Error('apiEndpoint is required');
+        }
+        this.apiEndpoint = apiEndpoint.replace(/\/$/, ''); // Remove trailing slash
+        this.apiKey = apiKey;
+    }
+    /**
+     * Set JWT token for authentication
+     */
+    setJwtToken(token) {
+        this.jwtToken = token;
+    }
+    /**
+     * Get current JWT token
+     */
+    getJwtToken() {
+        return this.jwtToken;
+    }
+    /**
+     * Check if JWT token is set
+     */
+    isAuthenticated() {
+        return !!this.jwtToken;
+    }
+    /**
+     * Send query to backend API
+     */
+    async sendQuery(request) {
+        if (!this.jwtToken && !this.apiKey) {
+            throw new Error('Authentication required: Set JWT token or API key. Call setJwtToken() first.');
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.jwtToken) {
+            headers['Authorization'] = `Bearer ${this.jwtToken}`;
+        }
+        else if (this.apiKey) {
+            headers['X-API-Key'] = this.apiKey;
+        }
+        try {
+            const response = await fetch(`${this.apiEndpoint}/api/aiorchestrator/query`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(request),
+            });
+            if (!response.ok) {
+                const errorData = await safeJson(response);
+                throw new ApiError(errorData?.message || `HTTP ${response.status}`, response.status, errorData);
+            }
+            const data = (await safeJson(response));
+            if (!data)
+                throw new ApiError('Empty response from server', 500);
+            // Ensure timestamp is a Date object
+            data.timestamp = new Date(data.timestamp);
+            return data;
+        }
+        catch (error) {
+            if (error instanceof ApiError) {
+                throw error;
+            }
+            throw new ApiError(`Failed to send query: ${String(error)}`, 500);
+        }
+    }
+    /**
+     * Check backend health
+     */
+    async checkHealth() {
+        try {
+            const response = await fetch(`${this.apiEndpoint}/health`);
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get API endpoint
+     */
+    getApiEndpoint() {
+        return this.apiEndpoint;
+    }
+}
+/**
+ * Custom API Error class
+ */
+export class ApiError extends Error {
+    constructor(message, statusCode, responseData) {
+        super(message);
+        this.statusCode = statusCode;
+        this.responseData = responseData;
+        this.name = 'ApiError';
+    }
+    isRateLimited() {
+        return this.statusCode === 429;
+    }
+    isUnauthorized() {
+        return this.statusCode === 401;
+    }
+    isBadRequest() {
+        return this.statusCode === 400;
+    }
+    isServerError() {
+        return this.statusCode >= 500;
+    }
+}

package/dist/core/src/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AI Widget Core SDK - Public API
+ * Framework-agnostic core library
+ */
+export * from './models';
+export { AiCommunicationService, ApiError } from './communication-service';
+export { ChatStateManager, ContextStateManager, ChartManager, SuggestionManager, } from './state-manager';
+export { PageContentScanner, AiSuggestionGenerator, type PageContent, } from './auto-suggestion-generator';
+export { AiWidgetSDK } from './sdk';
+export type { StateListener } from './state-manager';
+export { WIDGET_CSS } from './widget-css';

package/dist/core/src/index.js

@@ -0,0 +1,15 @@
+/**
+ * AI Widget Core SDK - Public API
+ * Framework-agnostic core library
+ */
+// Models
+export * from './models';
+// Services
+export { AiCommunicationService, ApiError } from './communication-service';
+export { ChatStateManager, ContextStateManager, ChartManager, SuggestionManager, } from './state-manager';
+// Auto-suggestion & page scanning
+export { PageContentScanner, AiSuggestionGenerator, } from './auto-suggestion-generator';
+// Main SDK
+export { AiWidgetSDK } from './sdk';
+// Canonical widget CSS (used by all framework packages)
+export { WIDGET_CSS } from './widget-css';

package/dist/core/src/models.d.ts

@@ -0,0 +1,137 @@
+/**
+ * AI Widget SDK - Shared Models
+ * Framework-agnostic type definitions used across all implementations
+ */
+export interface AiMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp: Date;
+    metadata?: {
+        hasChart: boolean;
+        charts?: AiChart[];
+        suggestedFollowUps?: string[];
+    };
+}
+export interface AiChart {
+    type: 'bar' | 'line' | 'pie' | 'doughnut' | 'radar';
+    title: string;
+    labels: string[];
+    datasets: ChartDataset[];
+    options?: ChartOptions;
+}
+export interface ChartDataset {
+    label: string;
+    data: number[];
+    backgroundColor?: string | string[];
+    borderColor?: string | string[];
+    tension?: number;
+    fill?: boolean;
+}
+export interface ChartOptions {
+    responsive?: boolean;
+    maintainAspectRatio?: boolean;
+    plugins?: {
+        legend?: {
+            display?: boolean;
+            position?: 'top' | 'bottom' | 'left' | 'right';
+        };
+        tooltip?: {
+            enabled?: boolean;
+        };
+    };
+    scales?: Record<string, any>;
+}
+export interface AiContext {
+    pageType: string;
+    entityId?: string;
+    userId?: string;
+    customData?: Record<string, any>;
+}
+export interface AiContextConfig {
+    context: AiContext;
+    apiEndpoint?: string;
+    apiKey?: string;
+    maxChatHistory?: number;
+    theme?: 'light' | 'dark';
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    enableCharts?: boolean;
+    enableExport?: boolean;
+    suggestionConfig?: SuggestionConfig;
+}
+export interface AiQueryRequest {
+    userQuery: string;
+    pageType: string;
+    entityId?: string;
+    contextData?: Record<string, any>;
+    [key: string]: any;
+}
+export interface AiQueryResponse {
+    sessionId: string;
+    response: string;
+    toolsUsed: string[];
+    tokensUsed: number;
+    cost: number;
+    timestamp: Date;
+}
+export interface AiErrorResponse {
+    error: string;
+    message: string;
+    statusCode: number;
+    timestamp: Date;
+}
+export interface ChartExportOptions {
+    format: 'csv' | 'json';
+    filename?: string;
+}
+export interface ChatExportData {
+    sessionId: string;
+    messages: AiMessage[];
+    charts: AiChart[];
+    exportedAt: Date;
+}
+/**
+ * Suggestion Models for Auto-suggestion Feature
+ */
+export interface AiSuggestion {
+    id: string;
+    text: string;
+    category?: string;
+    icon?: string;
+    description?: string;
+    metadata?: Record<string, any>;
+}
+export interface SuggestionGroup {
+    category: string;
+    suggestions: AiSuggestion[];
+    icon?: string;
+}
+export interface PageScanConfig {
+    enabled?: boolean;
+    autoScan?: boolean;
+    scanInterval?: number;
+    maxTextLength?: number;
+    excludeSelectors?: string[];
+    cacheDuration?: number;
+    mergeWithUserSuggestions?: boolean;
+}
+export interface AiSuggestionGeneratorConfig {
+    enabled?: boolean;
+    tier?: 'free' | 'premium';
+    backendUrl?: string;
+    apiKey?: string;
+    timeoutMs?: number;
+}
+export interface SuggestionConfig {
+    enabled: boolean;
+    suggestions?: AiSuggestion[];
+    categories?: SuggestionGroup[];
+    maxVisibleSuggestions?: number;
+    showOnFocus?: boolean;
+    showOnClick?: boolean;
+    customSuggestions?: (query: string) => Promise<AiSuggestion[]>;
+    autoGenerate?: boolean;
+    autoGenerateFreeTier?: boolean;
+    pageScanning?: PageScanConfig;
+    aiConfig?: AiSuggestionGeneratorConfig;
+}

package/dist/core/src/models.js

@@ -0,0 +1,5 @@
+/**
+ * AI Widget SDK - Shared Models
+ * Framework-agnostic type definitions used across all implementations
+ */
+export {};

package/dist/core/src/sdk.d.ts

@@ -0,0 +1,166 @@
+/**
+ * AI Widget SDK - Core SDK
+ * Main orchestrator that ties everything together
+ */
+import { AiCommunicationService } from './communication-service';
+import { ChatStateManager, ContextStateManager, ChartManager, SuggestionManager } from './state-manager';
+import { AiContextConfig, AiMessage, AiSuggestion } from './models';
+import { PageContentScanner, AiSuggestionGenerator } from './auto-suggestion-generator';
+export declare class AiWidgetSDK {
+    private communicationService;
+    private chatStateManager;
+    private contextStateManager;
+    private chartManager;
+    private suggestionManager;
+    private pageContentScanner;
+    private suggestionGenerator;
+    private config;
+    private autoSuggestionInterval?;
+    constructor(config: AiContextConfig);
+    /**
+     * Initialize auto-suggestions based on page content
+     */
+    initializeAutoSuggestions(): Promise<void>;
+    /**
+     * Validate configuration
+     */
+    private validateConfig;
+    /**
+     * Set JWT token for authentication
+     */
+    setJwtToken(token: string): void;
+    /**
+     * Send a query to the AI backend
+     */
+    sendQuery(userQuery: string): Promise<AiMessage>;
+    /**
+     * Update context
+     */
+    setContext(context: Partial<AiContextConfig['context']>): void;
+    /**
+     * Update single context property
+     */
+    updateContextProperty(key: string, value: any): void;
+    /**
+     * Get current context
+     */
+    getContext(): import("src").AiContext;
+    /**
+     * Clear chat history
+     */
+    clearChatHistory(): void;
+    /**
+     * Get chat messages
+     */
+    getMessages(): AiMessage[];
+    /**
+     * Get current error
+     */
+    getError(): string | null;
+    /**
+     * Check if loading
+     */
+    isLoading(): boolean;
+    /**
+     * Export chat history
+     */
+    exportChats(format?: 'json' | 'csv'): string;
+    /**
+     * Export charts
+     */
+    exportCharts(format?: 'json' | 'csv'): string;
+    /**
+     * Check backend health
+     */
+    checkHealth(): Promise<boolean>;
+    /**
+     * Subscribe to message changes
+     */
+    onMessagesChange(listener: (messages: AiMessage[]) => void): () => void;
+    /**
+     * Subscribe to loading changes
+     */
+    onLoadingChange(listener: (isLoading: boolean) => void): () => void;
+    /**
+     * Subscribe to error changes
+     */
+    onErrorChange(listener: (error: string | null) => void): () => void;
+    /**
+     * Subscribe to context changes
+     */
+    onContextChange(listener: (context: any) => void): () => void;
+    /**
+     * 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;
+    /**
+     * Subscribe to suggestion changes
+     */
+    onSuggestionsChange(listener: (suggestions: AiSuggestion[]) => void): () => void;
+    /**
+     * Get suggestion manager for advanced use
+     */
+    getSuggestionManager(): SuggestionManager;
+    /**
+     * Get internal services (for advanced use)
+     */
+    getServices(): {
+        communication: AiCommunicationService;
+        chatState: ChatStateManager;
+        contextState: ContextStateManager;
+        charts: ChartManager;
+        suggestions: SuggestionManager;
+    };
+    /**
+     * Trigger manual page scan for auto-suggestions
+     */
+    triggerAutoSuggestions(): Promise<void>;
+    /**
+     * Get page content scanner
+     */
+    getPageContentScanner(): PageContentScanner;
+    /**
+     * Get suggestion generator
+     */
+    getSuggestionGenerator(): AiSuggestionGenerator;
+    /**
+     * Stop auto-suggestion scanning
+     */
+    stopAutoSuggestions(): void;
+    /**
+     * Private helper to generate unique IDs
+     */
+    private generateId;
+    /**
+     * Private helper to extract error message
+     */
+    private getErrorMessage;
+}