floating-copilot-widget 1.4.3 → 1.5.1

package/dist/services/integrations.js

@@ -0,0 +1,281 @@
+/**
+ * API Integration Examples
+ *
+ * This file provides examples of how to create and configure API integrations
+ * for use with the Copilot chat widget.
+ */
+/**
+ * Example: Customer Creation API with Required Parameters
+ *
+ * This example shows how to integrate an API that creates a customer
+ * with interactive parameter collection
+ */
+export const createCustomerAPIIntegration = (baseUrl) => {
+    const requiredParams = [
+        {
+            name: 'name',
+            description: 'Customer full name',
+            type: 'string',
+            required: true,
+            example: 'John Doe'
+        },
+        {
+            name: 'email',
+            description: 'Customer email address',
+            type: 'email',
+            required: true,
+            validation: '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$',
+            example: 'john@example.com'
+        },
+        {
+            name: 'phone',
+            description: 'Customer phone number',
+            type: 'phone',
+            required: true,
+            example: '+1-555-123-4567'
+        },
+        {
+            name: 'company',
+            description: 'Company name (optional)',
+            type: 'string',
+            required: false,
+            example: 'Acme Corp'
+        }
+    ];
+    return {
+        id: 'create_customer',
+        name: 'Create Customer',
+        endpoint: `${baseUrl}/api/customers`,
+        method: 'POST',
+        intents: ['create_customer', 'add_customer', 'new_customer'],
+        requiredParameters: requiredParams,
+        buildRequest: (params) => ({
+            name: params.name,
+            email: params.email,
+            phone: params.phone,
+            company: params.company || null,
+            createdAt: new Date().toISOString()
+        }),
+        formatResponse: (data) => {
+            return `✅ **Customer Created Successfully**\n\n` +
+                `**ID**: ${data.id}\n` +
+                `**Name**: ${data.name}\n` +
+                `**Email**: ${data.email}\n` +
+                `**Phone**: ${data.phone}\n` +
+                (data.company ? `**Company**: ${data.company}\n` : '') +
+                `**Created**: ${new Date(data.createdAt).toLocaleDateString()}`;
+        },
+        shouldCall: (intent, params) => {
+            // Call when all required params are present
+            return !!(params.name && params.email && params.phone);
+        }
+    };
+};
+/**
+ * Example: REST API Integration
+ *
+ * This example shows how to integrate a generic REST API that returns user data
+ */
+export const createUserAPIIntegration = (baseUrl) => ({
+    id: 'user_api',
+    name: 'User Service API',
+    endpoint: `${baseUrl}/api/users`,
+    method: 'GET',
+    intents: ['get_user', 'find_user', 'lookup_user'],
+    buildRequest: (params) => {
+        // Transform intent parameters into API query string
+        const queryParams = new URLSearchParams();
+        if (params.userId)
+            queryParams.append('id', params.userId);
+        if (params.username)
+            queryParams.append('username', params.username);
+        if (params.email)
+            queryParams.append('email', params.email);
+        return queryParams.toString();
+    },
+    formatResponse: (data) => {
+        if (Array.isArray(data)) {
+            return data.map(user => `**${user.name}** (${user.email})\nID: ${user.id}\nRole: ${user.role}`).join('\n\n');
+        }
+        return `**${data.name}** (${data.email})\nID: ${data.id}\nRole: ${data.role}`;
+    },
+    shouldCall: (intent, params) => {
+        // Only call if we have identifying parameters
+        return !!(params.userId || params.username || params.email);
+    }
+});
+/**
+ * Example: Data Analysis API Integration
+ *
+ * This shows how to integrate an API that performs data analysis
+ */
+export const createAnalysisAPIIntegration = (baseUrl) => ({
+    id: 'analysis_api',
+    name: 'Data Analysis Service',
+    endpoint: `${baseUrl}/api/analysis`,
+    method: 'POST',
+    intents: ['analyze_data', 'generate_report', 'data_insights'],
+    buildRequest: (params) => ({
+        dataSource: params.dataSource,
+        analysisType: params.analysisType || 'summary',
+        timeRange: params.timeRange,
+        filters: params.filters || {}
+    }),
+    formatResponse: (data) => {
+        let response = `## Analysis Results\n\n`;
+        if (data.summary) {
+            response += `### Summary\n${data.summary}\n\n`;
+        }
+        if (data.metrics) {
+            response += `### Key Metrics\n`;
+            Object.entries(data.metrics).forEach(([key, value]) => {
+                response += `- **${key}**: ${value}\n`;
+            });
+            response += '\n';
+        }
+        if (data.recommendations) {
+            response += `### Recommendations\n`;
+            data.recommendations.forEach((rec) => {
+                response += `- ${rec}\n`;
+            });
+        }
+        return response;
+    },
+    shouldCall: (intent, params) => {
+        return !!(params.dataSource && params.analysisType);
+    }
+});
+/**
+ * Example: Search API Integration
+ *
+ * Shows how to integrate a search/query API
+ */
+export const createSearchAPIIntegration = (baseUrl) => ({
+    id: 'search_api',
+    name: 'Search Service',
+    endpoint: `${baseUrl}/api/search`,
+    method: 'POST',
+    intents: ['search', 'find', 'query'],
+    buildRequest: (params) => ({
+        query: params.query,
+        filters: {
+            type: params.type,
+            category: params.category,
+            dateRange: params.dateRange
+        },
+        limit: params.limit || 10,
+        offset: params.offset || 0
+    }),
+    formatResponse: (data) => {
+        if (!data.results || data.results.length === 0) {
+            return 'No results found matching your search criteria.';
+        }
+        let response = `Found **${data.results.length}** results:\n\n`;
+        response += data.results.map((result, index) => `${index + 1}. **${result.title}**\n   ${result.description}\n   URL: ${result.url}`).join('\n\n');
+        return response;
+    }
+});
+/**
+ * Example: Webhook/Action API Integration
+ *
+ * Shows how to integrate APIs that perform actions (create, update, delete)
+ */
+export const createActionAPIIntegration = (baseUrl) => ({
+    id: 'action_api',
+    name: 'Action Service',
+    endpoint: `${baseUrl}/api/actions`,
+    method: 'POST',
+    intents: ['create', 'update', 'delete', 'perform_action'],
+    buildRequest: (params) => ({
+        action: params.action,
+        targetId: params.targetId,
+        targetType: params.targetType,
+        payload: params.payload || {},
+        metadata: params.metadata || {}
+    }),
+    formatResponse: (data) => {
+        if (data.success) {
+            return `✅ **Action Completed Successfully**\n\n${data.message || 'The requested action has been performed.'}\n\nDetails: ${JSON.stringify(data.result, null, 2)}`;
+        }
+        return `❌ **Action Failed**\n\n${data.message || 'The requested action could not be completed.'}`;
+    }
+});
+/**
+ * Example: Database Query Integration
+ *
+ * Shows how to integrate a database query service
+ */
+export const createDatabaseAPIIntegration = (baseUrl) => ({
+    id: 'database_api',
+    name: 'Database Query Service',
+    endpoint: `${baseUrl}/api/query`,
+    method: 'POST',
+    intents: ['query_database', 'get_data', 'fetch_records'],
+    buildRequest: (params) => ({
+        table: params.table,
+        columns: params.columns || ['*'],
+        where: params.where || {},
+        orderBy: params.orderBy,
+        limit: params.limit || 50
+    }),
+    formatResponse: (data) => {
+        if (!data.rows || data.rows.length === 0) {
+            return 'No records found matching your query.';
+        }
+        let response = `Retrieved **${data.rows.length}** records:\n\n`;
+        // Format as table if we have column information
+        if (data.columns && data.columns.length > 0) {
+            response += `| ${data.columns.join(' | ')} |\n`;
+            response += `|${data.columns.map(() => '-').join('|')}|\n`;
+            data.rows.forEach((row) => {
+                response += `| ${data.columns.map((col) => row[col] || '-').join(' | ')} |\n`;
+            });
+        }
+        else {
+            // Fallback: display as JSON
+            response += '```json\n' + JSON.stringify(data.rows, null, 2) + '\n```';
+        }
+        return response;
+    }
+});
+/**
+ * Example: External Service Integration (Weather, News, etc.)
+ */
+export const createWeatherAPIIntegration = (apiKey) => ({
+    id: 'weather_api',
+    name: 'Weather Service',
+    endpoint: 'https://api.openweathermap.org/data/2.5/weather',
+    method: 'GET',
+    headers: {
+        'User-Agent': 'FloatingCopilot/1.0'
+    },
+    intents: ['get_weather', 'weather', 'check_weather'],
+    buildRequest: (params) => {
+        // Note: For actual use, pass apiKey securely
+        return {
+            q: params.city,
+            appid: apiKey,
+            units: params.units || 'metric'
+        };
+    },
+    formatResponse: (data) => {
+        var _a, _b, _c;
+        const weather = (_a = data.weather) === null || _a === void 0 ? void 0 : _a[0];
+        const main = data.main;
+        return `**Weather for ${data.name}, ${(_b = data.sys) === null || _b === void 0 ? void 0 : _b.country}**
+
+Current: ${weather === null || weather === void 0 ? void 0 : weather.main} (${weather === null || weather === void 0 ? void 0 : weather.description})
+Temperature: ${main === null || main === void 0 ? void 0 : main.temp}°C
+Feels like: ${main === null || main === void 0 ? void 0 : main.feels_like}°C
+Humidity: ${main === null || main === void 0 ? void 0 : main.humidity}%
+Wind Speed: ${(_c = data.wind) === null || _c === void 0 ? void 0 : _c.speed} m/s
+
+Updated: ${new Date(data.dt * 1000).toLocaleString()}`;
+    }
+});
+/**
+ * Helper function to create a custom API integration
+ */
+export function createCustomAPIIntegration(config) {
+    return config;
+}

package/dist/types/copilot.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Copilot Integration Types
+ *
+ * Defines interfaces and types for GitHub Copilot integration
+ * with the floating chat widget.
+ */
+export interface CopilotConfig {
+    /**
+     * GitHub Personal Access Token for Copilot API access
+     * Required scopes: copilot, read:user
+     *
+     * Can be provided explicitly or read from environment variables:
+     * - GITHUB_TOKEN
+     * - VITE_GITHUB_TOKEN (for Vite projects)
+     * - REACT_APP_GITHUB_TOKEN (for Create React App)
+     *
+     * If not provided, the service will automatically check environment variables.
+     */
+    githubToken?: string;
+    /**
+     * AI model to use (default: gpt-4o)
+     */
+    model?: string;
+    /**
+     * Maximum tokens for API responses (default: 2000)
+     */
+    maxTokens?: number;
+    /**
+     * Temperature for response generation (0-1, default: 0.3)
+     */
+    temperature?: number;
+}
+export interface CopilotIntentRequest {
+    /**
+     * User message or query
+     */
+    userMessage: string;
+    /**
+     * Context data from the application
+     */
+    context?: Record<string, any>;
+    /**
+     * Custom instructions for intent analysis
+     */
+    customInstructions?: string;
+}
+export interface ParameterDefinition {
+    /**
+     * Parameter name/key
+     */
+    name: string;
+    /**
+     * User-friendly description for prompting
+     */
+    description: string;
+    /**
+     * Data type: string, number, email, phone, date, etc.
+     */
+    type?: string;
+    /**
+     * Is this parameter required?
+     */
+    required?: boolean;
+    /**
+     * Validation regex pattern
+     */
+    validation?: string;
+    /**
+     * Example value to show user
+     */
+    example?: string;
+}
+export interface CopilotIntentResponse {
+    /**
+     * Identified intent of the user message
+     */
+    intent: string;
+    /**
+     * Confidence score (0-1)
+     */
+    confidence: number;
+    /**
+     * Extracted parameters from the user message
+     */
+    parameters: Record<string, any>;
+    /**
+     * Suggested API endpoints to call
+     */
+    suggestedApis: string[];
+    /**
+     * Raw response from Copilot
+     */
+    rawResponse: string;
+    /**
+     * Required parameters for the API (if parameter collection is needed)
+     */
+    requiredParameters?: ParameterDefinition[];
+    /**
+     * Parameters that are still missing
+     */
+    missingParameters?: string[];
+}
+export interface APIIntegration {
+    /**
+     * Unique identifier for this API
+     */
+    id: string;
+    /**
+     * API name/description
+     */
+    name: string;
+    /**
+     * API endpoint URL
+     */
+    endpoint: string;
+    /**
+     * HTTP method (GET, POST, PUT, DELETE, etc.)
+     */
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    /**
+     * Headers to include in the request
+     */
+    headers?: Record<string, string>;
+    /**
+     * Intents that should trigger this API
+     */
+    intents?: string[];
+    /**
+     * Required parameters for this API
+     * If provided, system will interactively collect missing parameters
+     */
+    requiredParameters?: ParameterDefinition[];
+    /**
+     * Function to transform user message into API request
+     */
+    buildRequest: (params: Record<string, any>, context?: Record<string, any>) => any;
+    /**
+     * Function to format API response for display
+     */
+    formatResponse: (data: any) => string;
+    /**
+     * Optional: Function to check if this API should be called for a given intent
+     */
+    shouldCall?: (intent: string, parameters: Record<string, any>) => boolean;
+}
+export interface APICallRequest {
+    /**
+     * API integration ID
+     */
+    apiId: string;
+    /**
+     * Parameters extracted from user intent
+     */
+    parameters: Record<string, any>;
+    /**
+     * Application context
+     */
+    context?: Record<string, any>;
+}
+export interface APICallResponse {
+    /**
+     * Success status
+     */
+    success: boolean;
+    /**
+     * Formatted response data
+     */
+    data?: string;
+    /**
+     * Raw API response (for debugging)
+     */
+    rawData?: any;
+    /**
+     * Error message if failed
+     */
+    error?: string;
+    /**
+     * API that was called
+     */
+    apiName?: string;
+}
+export interface CopilotChatMessage {
+    /**
+     * Role of the message sender
+     */
+    role: 'user' | 'assistant' | 'system';
+    /**
+     * Message content
+     */
+    content: string;
+    /**
+     * Associated API call if this was generated from API
+     */
+    apiCall?: {
+        apiId: string;
+        apiName: string;
+        rawData: any;
+    };
+    /**
+     * Intent information if this was intent analysis
+     */
+    intent?: {
+        intent: string;
+        confidence: number;
+        parameters: Record<string, any>;
+    };
+}

package/dist/types/copilot.js

@@ -0,0 +1,7 @@
+/**
+ * Copilot Integration Types
+ *
+ * Defines interfaces and types for GitHub Copilot integration
+ * with the floating chat widget.
+ */
+export {};

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { CopilotConfig, APIIntegration } from './types/copilot';
 export interface FloatingCopilotConfig {
     position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
     width?: number;
@@ -24,5 +25,11 @@ export interface FloatingCopilotConfig {
     showMaximizeBtn?: boolean;
     showCloseBtn?: boolean;
     headerContent?: string;
+    copilot?: {
+        config: CopilotConfig;
+        apiIntegrations?: APIIntegration[];
+        enabled?: boolean;
+        showIntentAnalysis?: boolean;
+    };
 }
 export declare const defaultConfig: FloatingCopilotConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "floating-copilot-widget",
-  "version": "1.4.3",
+  "version": "1.5.1",
   "description": "A highly configurable floating chat widget plugin for React websites. Draggable, resizable, themeable, and production-ready.",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",