@widgetic/chat 0.1.4

package/dist/types/adapter.d.ts

@@ -0,0 +1,86 @@
+import type { ChatContext, ContextCapabilities } from './context.js';
+import type { ChatConfig } from './config.js';
+/**
+ * Platform adapter interface for different contexts
+ */
+export interface PlatformAdapter {
+    name: string;
+    version: string;
+    getContextId(contextObject: any): string;
+    getContextTitle(contextObject: any): string;
+    getContextType(): string;
+    createContext(contextObject: any): ChatContext;
+    getCapabilities(): ContextCapabilities;
+    getSuggestions(context: ChatContext): Promise<string[]>;
+    getActions(context: ChatContext): Promise<any[]>;
+    captureScreenshot?(contextId: string): Promise<Blob>;
+    startRecording?(contextId: string): Promise<void>;
+    stopRecording?(): Promise<Blob>;
+    onContextChange?(callback: (context: ChatContext | null) => void): () => void;
+    onContextUpdate?(callback: (context: ChatContext) => void): () => void;
+}
+/**
+ * Widgetic canvas adapter for frame-based contexts
+ */
+export interface WidgeticAdapter extends PlatformAdapter {
+    name: 'widgetic';
+    getFrameContent(frameId: string): Promise<any>;
+    captureFrameScreenshot(frameId: string): Promise<Blob>;
+    startFrameRecording(frameId: string): Promise<void>;
+    onFrameSelection(callback: (frameId: string) => void): () => void;
+    onFrameDeselection(callback: (frameId: string) => void): () => void;
+}
+/**
+ * Text editor adapter for document-based contexts
+ */
+export interface TextEditorAdapter extends PlatformAdapter {
+    name: 'text-editor';
+    getSelectedText(): string;
+    getDocumentContent(): string;
+    insertText(text: string): void;
+    onTextSelection(callback: (selection: any) => void): () => void;
+}
+/**
+ * Adapter factory for creating platform-specific adapters
+ */
+export interface AdapterFactory {
+    createAdapter(platform: string, config?: Partial<ChatConfig>): PlatformAdapter;
+    registerAdapter(platform: string, adapterClass: new (...args: any[]) => PlatformAdapter): void;
+    getAvailableAdapters(): string[];
+}
+/**
+ * Adapter configuration options
+ */
+export interface AdapterConfig {
+    platform: string;
+    autoDetect?: boolean;
+    fallbackPlatform?: string;
+    customAdapters?: Record<string, new (...args: any[]) => PlatformAdapter>;
+}
+/**
+ * Adapter integration event types
+ */
+export type AdapterEvent = {
+    type: 'context_selected';
+    context: ChatContext;
+} | {
+    type: 'context_deselected';
+    context: ChatContext;
+} | {
+    type: 'context_updated';
+    context: ChatContext;
+} | {
+    type: 'media_captured';
+    mediaUrl: string;
+    mediaType: string;
+} | {
+    type: 'suggestion_selected';
+    suggestion: string;
+} | {
+    type: 'action_triggered';
+    actionId: string;
+};
+/**
+ * Adapter event handler
+ */
+export type AdapterEventHandler = (event: AdapterEvent) => void | Promise<void>;

package/dist/types/adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api-temp.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Temporary API type definitions until @widgetic/api-sdk is properly linked
+ * This file should be removed once the SDK deployment is complete
+ */
+export interface Message {
+    id: string;
+    conversationId: string;
+    messageContent?: string | null;
+    messageType: 'user' | 'assistant';
+    attachments?: ContentItemOutput[];
+    isCommit?: boolean;
+    userId: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Conversation {
+    id: string;
+    title: string;
+    completed: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ContentItemOutput {
+    id: string;
+    url: string;
+    file_type: string;
+    file_name?: string | null;
+    file_size?: number | null;
+    metadata?: Record<string, any> | null;
+    created_at: string;
+    display_order: number;
+}
+export interface CreateConversationRequest {
+    title: string;
+    completed: boolean;
+}
+export interface CreateMessageRequest {
+    messageContent: string;
+    messageType: 'user' | 'assistant';
+    attachments?: any[];
+}
+export declare class ConversationsApi {
+    constructor(configuration?: any);
+    getConversations(params: {
+        canvasId: string;
+        componentId: string;
+    }): Promise<void>;
+    createConversation(params: {
+        canvasId: string;
+        componentId: string;
+        createConversationRequest: CreateConversationRequest;
+    }): Promise<Conversation>;
+}
+export declare class MessagesApi {
+    constructor(configuration?: any);
+    getMessages(conversationId: string): Promise<Message[]>;
+    createMessage(params: {
+        conversationId: string;
+        createMessageRequest: CreateMessageRequest;
+    }): Promise<Message>;
+}

package/dist/types/api-temp.js

@@ -0,0 +1,42 @@
+/**
+ * Temporary API type definitions until @widgetic/api-sdk is properly linked
+ * This file should be removed once the SDK deployment is complete
+ */
+// Mock API classes for temporary use
+export class ConversationsApi {
+    constructor(configuration) { }
+    async getConversations(params) {
+        // Mock implementation
+    }
+    async createConversation(params) {
+        // Mock implementation
+        return {
+            id: `conv_${Date.now()}`,
+            title: params.createConversationRequest.title,
+            completed: params.createConversationRequest.completed,
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+    }
+}
+export class MessagesApi {
+    constructor(configuration) { }
+    async getMessages(conversationId) {
+        // Mock implementation
+        return [];
+    }
+    async createMessage(params) {
+        // Mock implementation
+        return {
+            id: `msg_${Date.now()}`,
+            conversationId: params.conversationId,
+            messageType: params.createMessageRequest.messageType,
+            messageContent: params.createMessageRequest.messageContent,
+            isCommit: false,
+            userId: 'test_user',
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            attachments: []
+        };
+    }
+}

package/dist/types/attachment.d.ts

@@ -0,0 +1,84 @@
+import type { ContentItemOutput } from './message.js';
+/**
+ * File attachment types
+ */
+export type AttachmentType = 'image' | 'video' | 'document' | 'other';
+/**
+ * Attachment upload status
+ */
+export type UploadStatus = 'pending' | 'uploading' | 'completed' | 'failed';
+/**
+ * Input for creating attachments
+ */
+export interface AttachmentInput {
+    file: File;
+    type?: AttachmentType;
+    metadata?: Record<string, any>;
+    preview?: string;
+    /** Stable CDN URL after upload service persists the file */
+    uploadedUrl?: string;
+    /** Widgetic uploads row id (for codegen attachmentIds) */
+    uploadId?: string;
+    uploadProgress?: number;
+}
+/**
+ * Client-side attachment before upload
+ */
+export interface PendingAttachment {
+    id: string;
+    file: File;
+    type: AttachmentType;
+    preview?: string;
+    uploadStatus: UploadStatus;
+    uploadProgress: number;
+    error?: string;
+    retryCount: number;
+}
+/**
+ * Processed attachment from API
+ */
+export interface ProcessedAttachment extends ContentItemOutput {
+    type: AttachmentType;
+    previewUrl?: string;
+    downloadUrl?: string;
+}
+/**
+ * Attachment validation result
+ */
+export interface AttachmentValidation {
+    valid: boolean;
+    error?: string;
+    code?: 'FILE_TOO_LARGE' | 'INVALID_TYPE' | 'TOO_MANY_FILES' | 'UNSUPPORTED_FORMAT';
+}
+/**
+ * Attachment upload progress event
+ */
+export interface UploadProgressEvent {
+    attachmentId: string;
+    progress: number;
+    loaded: number;
+    total: number;
+}
+/**
+ * Attachment display configuration
+ */
+export interface AttachmentDisplayConfig {
+    showThumbnails: boolean;
+    maxThumbnailSize: number;
+    enableLightbox: boolean;
+    groupSimilarTypes: boolean;
+}
+/**
+ * File type detection utilities
+ */
+export interface FileTypeInfo {
+    type: AttachmentType;
+    icon: string;
+    preview: boolean;
+    accept: string[];
+    maxSize?: number;
+}
+/**
+ * Supported file types configuration
+ */
+export declare const FILE_TYPE_CONFIG: Record<AttachmentType, FileTypeInfo>;

package/dist/types/attachment.js

@@ -0,0 +1,33 @@
+/**
+ * Supported file types configuration
+ */
+export var FILE_TYPE_CONFIG = {
+    image: {
+        type: 'image',
+        icon: 'image',
+        preview: true,
+        accept: ['image/jpeg', 'image/png', 'image/svg+xml'],
+        maxSize: 10 * 1024 * 1024, // 10MB
+    },
+    video: {
+        type: 'video',
+        icon: 'video',
+        preview: true,
+        accept: ['video/mp4'],
+        maxSize: 100 * 1024 * 1024, // 100MB
+    },
+    document: {
+        type: 'document',
+        icon: 'file-text',
+        preview: false,
+        accept: ['application/pdf', 'text/plain', 'text/markdown', '.mermaid', '.md'],
+        maxSize: 25 * 1024 * 1024, // 25MB
+    },
+    other: {
+        type: 'other',
+        icon: 'file',
+        preview: false,
+        accept: ['*/*'],
+        maxSize: 10 * 1024 * 1024, // 10MB
+    },
+};

package/dist/types/chat.d.ts

@@ -0,0 +1,114 @@
+import type { ChatConfig } from './config.js';
+import type { ChatContext } from './context.js';
+import type { ChatConversation } from './conversation.js';
+import type { ChatMessage } from './message.js';
+import type { PlatformAdapter } from './adapter.js';
+import type { ChatEventEmitter } from './events.js';
+/**
+ * Main chat instance interface
+ */
+export interface ChatInstance {
+    readonly config: ChatConfig;
+    readonly context: ChatContext | null;
+    readonly adapter: PlatformAdapter;
+    readonly events: ChatEventEmitter;
+    isExpanded: boolean;
+    isLoading: boolean;
+    currentConversation: ChatConversation | null;
+    initialize(): Promise<void>;
+    destroy(): void;
+    attachToContext(context: ChatContext): void;
+    detachFromContext(): void;
+    expand(): void;
+    collapse(): void;
+    toggle(): void;
+    createConversation(title?: string): Promise<ChatConversation>;
+    loadConversation(conversationId: string): Promise<void>;
+    deleteConversation(conversationId: string): Promise<void>;
+    sendMessage(content: string, attachments?: File[]): Promise<ChatMessage>;
+    loadMessages(conversationId: string): Promise<ChatMessage[]>;
+    captureScreenshot?(): Promise<string>;
+    startRecording?(): Promise<void>;
+    stopRecording?(): Promise<string>;
+    uploadFile(file: File): Promise<string>;
+    validateFile(file: File): Promise<boolean>;
+}
+/**
+ * Chat instance factory options
+ */
+export interface ChatInstanceOptions {
+    config?: Partial<ChatConfig>;
+    adapter?: PlatformAdapter | string;
+    context?: ChatContext;
+    autoExpand?: boolean;
+}
+/**
+ * Chat factory interface
+ */
+export interface ChatFactory {
+    createInstance(options: ChatInstanceOptions): Promise<ChatInstance>;
+    registerAdapter(name: string, adapter: PlatformAdapter): void;
+    getAvailableAdapters(): string[];
+}
+/**
+ * Chat plugin interface for extending functionality
+ */
+export interface ChatPlugin {
+    name: string;
+    version: string;
+    install(instance: ChatInstance): void | Promise<void>;
+    uninstall(instance: ChatInstance): void | Promise<void>;
+}
+/**
+ * Chat analytics event
+ */
+export interface ChatAnalyticsEvent {
+    event: string;
+    properties?: Record<string, any>;
+    userId?: string;
+    contextId?: string;
+    conversationId?: string;
+    timestamp: Date;
+}
+/**
+ * Chat service interface for backend integration
+ */
+export interface ChatService {
+    getConversations(contextId: string): Promise<ChatConversation[]>;
+    createConversation(contextId: string, data: any): Promise<ChatConversation>;
+    updateConversation(conversationId: string, updates: any): Promise<ChatConversation>;
+    deleteConversation(conversationId: string): Promise<void>;
+    getMessages(conversationId: string): Promise<ChatMessage[]>;
+    sendMessage(conversationId: string, data: any): Promise<ChatMessage>;
+    updateMessage(messageId: string, updates: any): Promise<ChatMessage>;
+    deleteMessage(messageId: string): Promise<void>;
+    uploadFile(file: File): Promise<string>;
+    processAIResponse(conversationId: string, message: ChatMessage): Promise<ChatMessage>;
+}
+/**
+ * Chat component events
+ */
+export interface ChatEvents {
+    messageReceived: CustomEvent<{
+        message: ChatMessage;
+        conversationId: string;
+    }>;
+    messageSent: CustomEvent<{
+        message: ChatMessage;
+        conversationId: string;
+    }>;
+    conversationCreated: CustomEvent<{
+        conversation: ChatConversation;
+    }>;
+    contextChanged: CustomEvent<{
+        context: ChatContext | null;
+    }>;
+    fileUploaded: CustomEvent<{
+        url: string;
+        fileName: string;
+    }>;
+    error: CustomEvent<{
+        message: string;
+        code?: string;
+    }>;
+}

package/dist/types/chat.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config.d.ts

@@ -0,0 +1,89 @@
+import type { ContextCapabilities } from './context.js';
+import { ContextType } from './context.js';
+/**
+ * Chat configuration options
+ */
+export interface ChatConfig {
+    api: {
+        baseUrl?: string;
+        headers?: Record<string, string>;
+        timeout?: number;
+    };
+    ui: {
+        position: 'right' | 'bottom' | 'left' | 'floating';
+        width?: number;
+        height?: number;
+        minWidth?: number;
+        minHeight?: number;
+        showTimestamps?: boolean;
+        showAvatars?: boolean;
+        groupMessages?: boolean;
+        maxFileSize?: number;
+        /**
+         * File types that users can drag/drop and upload to the chat
+         * These are MIME types and file extensions for user uploads
+         */
+        allowedFileTypes?: string[];
+    };
+    platform: {
+        name: string;
+        type: ContextType;
+        capabilities: ContextCapabilities;
+        suggestions?: string[];
+        actions?: ChatAction[];
+    };
+    features: {
+        fileUpload: boolean;
+        voiceTranscription: boolean;
+        screenshot: boolean;
+        aiSuggestions: boolean;
+        screenRecording: boolean;
+        restoreCheckpoint: boolean;
+        /**
+         * Debug: auto-detect code patterns in plain-text messages and render them
+         * as syntax-highlighted code blocks (even without explicit ``` fences).
+         * Defaults to false to prevent assistant summaries that mention file paths
+         * from being misclassified as JavaScript.
+         */
+        autoCodeDetection?: boolean;
+        /**
+         * Debug: show backend-generated "Updated N files: ..." summaries in the
+         * chat UI. Useful for verifying what the agent actually touched during
+         * multi-turn edits (Aider diff mode). Default false — these messages are
+         * mostly noise for end users; they still get stored in the DB and used as
+         * LLM conversation history regardless of this flag.
+         */
+        showGenerationSummaries?: boolean;
+    };
+    websocket?: {
+        enabled: boolean;
+        url?: string;
+        reconnectAttempts?: number;
+        reconnectDelay?: number;
+    };
+    mediaCapture?: {
+        maxVideoLength?: number;
+        videoQuality?: 'low' | 'medium' | 'high';
+        /**
+         * Format for screenshots captured BY THE APP (not user uploads)
+         * When the app takes a screenshot of the frame/canvas, what format to save it in
+         */
+        screenshotFormat?: 'png' | 'jpeg';
+        autoCapture?: boolean;
+    };
+}
+/**
+ * Chat action configuration
+ */
+export interface ChatAction {
+    id: string;
+    label: string;
+    icon: string;
+    shortcut?: string;
+    position?: 'primary' | 'secondary';
+    handler: () => void | Promise<void>;
+}
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_CHAT_CONFIG: ChatConfig;

package/dist/types/config.js

@@ -0,0 +1,63 @@
+import { ContextType } from './context.js';
+/**
+ * Default configuration values
+ */
+export var DEFAULT_CHAT_CONFIG = {
+    api: {
+        timeout: 30000,
+    },
+    ui: {
+        position: 'right',
+        width: 320,
+        minWidth: 280,
+        minHeight: 400,
+        showTimestamps: true,
+        showAvatars: true,
+        groupMessages: true,
+        maxFileSize: 10 * 1024 * 1024, // 10MB
+        allowedFileTypes: [
+            'image/jpeg',
+            'image/png',
+            'image/svg+xml',
+            'video/mp4',
+            'application/pdf',
+            'text/plain',
+            'text/markdown',
+            '.mermaid',
+        ],
+    },
+    platform: {
+        name: 'default',
+        type: ContextType.FRAME,
+        capabilities: {
+            supportsScreenshot: false,
+            supportsRecording: false,
+            supportsFileUpload: true,
+            supportsTextInput: true,
+            supportsMediaCapture: false,
+        },
+        suggestions: [],
+        actions: [],
+    },
+    features: {
+        fileUpload: true,
+        voiceTranscription: false,
+        screenshot: false,
+        aiSuggestions: true,
+        screenRecording: false,
+        restoreCheckpoint: false,
+        autoCodeDetection: false,
+        showGenerationSummaries: false,
+    },
+    websocket: {
+        enabled: false,
+        reconnectAttempts: 3,
+        reconnectDelay: 1000,
+    },
+    mediaCapture: {
+        maxVideoLength: 300, // 5 minutes
+        videoQuality: 'medium',
+        screenshotFormat: 'png',
+        autoCapture: false,
+    },
+};

package/dist/types/context.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Chat context types for different platforms and objects
+ */
+export declare enum ContextType {
+    FRAME = "frame",
+    TEXT = "text",
+    IMAGE = "image",
+    DOCUMENT = "document",
+    CANVAS = "canvas"
+}
+/**
+ * Context descriptor for platform-agnostic chat attachment
+ */
+export interface ChatContext {
+    id: string;
+    type: ContextType;
+    parentId: string;
+    title?: string;
+    thumbnail?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Frame-specific context for Widgetic canvas
+ */
+export interface FrameContext extends ChatContext {
+    type: ContextType.FRAME;
+    metadata?: {
+        isPublished?: boolean;
+        dimensions?: {
+            width: number;
+            height: number;
+        };
+        frameTitle?: string;
+        canvasId?: string;
+    };
+}
+/**
+ * Text-specific context for document editing
+ */
+export interface TextContext extends ChatContext {
+    type: ContextType.TEXT;
+    metadata?: {
+        contentType?: string;
+        wordCount?: number;
+        language?: string;
+        selection?: {
+            start: number;
+            end: number;
+        };
+    };
+}
+/**
+ * Image-specific context for image editing
+ */
+export interface ImageContext extends ChatContext {
+    type: ContextType.IMAGE;
+    metadata?: {
+        dimensions?: {
+            width: number;
+            height: number;
+        };
+        format?: string;
+        fileSize?: number;
+        [key: string]: any;
+    };
+}
+/**
+ * Document-specific context for document editing
+ */
+export interface DocumentContext extends ChatContext {
+    type: ContextType.DOCUMENT;
+    metadata?: {
+        fileType?: string;
+        pageCount?: number;
+        fileSize?: number;
+        [key: string]: any;
+    };
+}
+/**
+ * Canvas-specific context for canvas editing
+ */
+export interface CanvasContext extends ChatContext {
+    type: ContextType.CANVAS;
+    metadata?: {
+        componentCount?: number;
+        lastModified?: string;
+        [key: string]: any;
+    };
+}
+/**
+ * Context selection event
+ */
+export interface ContextSelectionEvent {
+    type: 'selected' | 'deselected';
+    context: ChatContext;
+    timestamp: Date;
+}
+/**
+ * Context capabilities for different platforms
+ */
+export interface ContextCapabilities {
+    supportsScreenshot: boolean;
+    supportsRecording: boolean;
+    supportsFileUpload: boolean;
+    supportsTextInput: boolean;
+    supportsMediaCapture: boolean;
+}
+export type AnyContext = FrameContext | TextContext | ImageContext | DocumentContext | CanvasContext;

package/dist/types/context.js

@@ -0,0 +1,11 @@
+/**
+ * Chat context types for different platforms and objects
+ */
+export var ContextType;
+(function (ContextType) {
+    ContextType["FRAME"] = "frame";
+    ContextType["TEXT"] = "text";
+    ContextType["IMAGE"] = "image";
+    ContextType["DOCUMENT"] = "document";
+    ContextType["CANVAS"] = "canvas";
+})(ContextType || (ContextType = {}));