@cometchat/skills 3.0.0 → 4.0.0

package/skills/cometchat-android-v6-events/SKILL.md

@@ -0,0 +1,212 @@
+---
+name: cometchat-android-v6-events
+description: "CometChat Android UIKit v6 event system — SharedFlow-based reactive event bus for messages, calls, users, groups, conversations, and UI events"
+license: "MIT"
+compatibility: "Android 9.0+ (API 28); Kotlin 1.9+; com.cometchat:chatuikit-core-android:6.x"
+allowed-tools: "executeBash, readFile, fileSearch, listDirectory"
+metadata:
+  author: "CometChat"
+  version: "3.0.0"
+  tags: "cometchat, android, events, sharedflow, kotlin-flow, reactive"
+---
+
+> **Companion skills:** cometchat-android-v6-core (init/login), cometchat-android-v6-kotlin-customization, cometchat-android-v6-compose-customization
+
+## Purpose
+
+Subscribe to and emit CometChat events using the v6 Kotlin SharedFlow-based event bus. This replaces the v5 Java listener interface pattern with a reactive, type-safe system built on `kotlinx.coroutines.flow.SharedFlow`.
+
+## Use this skill when
+
+- Listening for message sent/received/edited/deleted events
+- Listening for call accepted/rejected/ended events
+- Listening for user or group membership changes
+- Listening for conversation updates
+- Listening for UI events (custom UI position events)
+- Emitting custom events to trigger UI updates
+
+## Do not use this skill when
+
+- Setting up the SDK (use `cometchat-android-v6-core`)
+- Working with CometChat SDK-level listeners (`CometChat.addMessageListener`) — those are separate from UIKit events
+
+## 1. Event Bus Architecture
+
+`CometChatEvents` is a singleton object in `com.cometchat.uikit.core.events` that manages 6 event flows:
+
+```kotlin
+import com.cometchat.uikit.core.events.CometChatEvents
+
+// 6 event flows — all are SharedFlow<T>
+CometChatEvents.messageEvents       // SharedFlow<CometChatMessageEvent>
+CometChatEvents.callEvents          // SharedFlow<CometChatCallEvent>
+CometChatEvents.userEvents          // SharedFlow<CometChatUserEvent>
+CometChatEvents.groupEvents         // SharedFlow<CometChatGroupEvent>
+CometChatEvents.conversationEvents  // SharedFlow<CometChatConversationEvent>
+CometChatEvents.uiEvents            // SharedFlow<CometChatUIEvent>
+```
+
+Each flow uses:
+- `replay = 0` — no replay of past events to new subscribers
+- `BufferOverflow.DROP_OLDEST` — drops oldest events when buffer is full
+- Buffer capacities: messages=64, groups=32, users/conversations/ui=16, calls=8
+
+## 2. Subscribing to Events
+
+### 2.1 In a ViewModel or CoroutineScope
+
+```kotlin
+import com.cometchat.uikit.core.events.*
+import kotlinx.coroutines.launch
+
+// In a ViewModel
+viewModelScope.launch {
+    CometChatEvents.messageEvents.collect { event ->
+        when (event) {
+            is CometChatMessageEvent.MessageSent -> {
+                val message = event.message
+                val status = event.status // IN_PROGRESS, SUCCESS, or ERROR
+            }
+            is CometChatMessageEvent.MessageEdited -> {
+                val editedMessage = event.message
+            }
+            is CometChatMessageEvent.MessageDeleted -> {
+                val deletedMessage = event.message
+            }
+            // handle other message events...
+            else -> {}
+        }
+    }
+}
+```
+
+### 2.2 In Jetpack Compose
+
+```kotlin
+import androidx.compose.runtime.LaunchedEffect
+import com.cometchat.uikit.core.events.*
+
+@Composable
+fun ChatScreen() {
+    LaunchedEffect(Unit) {
+        CometChatEvents.callEvents.collect { event ->
+            when (event) {
+                is CometChatCallEvent.CallAccepted -> {
+                    // Navigate to ongoing call screen
+                }
+                is CometChatCallEvent.CallRejected -> {
+                    // Dismiss call UI
+                }
+                else -> {}
+            }
+        }
+    }
+}
+```
+
+### 2.3 In an Activity or Application class
+
+```kotlin
+private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    
+    scope.launch {
+        CometChatEvents.callEvents.collect { event ->
+            when (event) {
+                is CometChatCallEvent.CallAccepted -> { /* ... */ }
+                is CometChatCallEvent.CallRejected -> { /* ... */ }
+                else -> {}
+            }
+        }
+    }
+}
+
+override fun onDestroy() {
+    super.onDestroy()
+    scope.cancel() // Always cancel to avoid leaks
+}
+```
+
+## 3. Emitting Events
+
+```kotlin
+// Emit a message event
+CometChatEvents.emitMessageEvent(
+    CometChatMessageEvent.MessageSent(message, MessageStatus.SUCCESS)
+)
+
+// Emit a call event
+CometChatEvents.emitCallEvent(
+    CometChatCallEvent.CallRejected(call)
+)
+
+// Emit a user event
+CometChatEvents.emitUserEvent(event)
+
+// Emit a group event
+CometChatEvents.emitGroupEvent(event)
+
+// Emit a conversation event
+CometChatEvents.emitConversationEvent(event)
+
+// Emit a UI event
+CometChatEvents.emitUIEvent(event)
+```
+
+All emit functions are thread-safe — they launch on `Dispatchers.Default` internally.
+
+## 4. Event Types Reference
+
+### 4.1 CometChatMessageEvent (sealed class)
+
+| Event | Properties | When emitted |
+|---|---|---|
+| `MessageSent` | `message: BaseMessage`, `status: MessageStatus` | Text/media/custom message sent (IN_PROGRESS → SUCCESS or ERROR) |
+| `MessageEdited` | `message: BaseMessage` | Message edited |
+| `MessageDeleted` | `message: BaseMessage` | Message deleted |
+
+`MessageStatus` enum: `IN_PROGRESS`, `SUCCESS`, `ERROR`
+
+### 4.2 CometChatCallEvent (sealed class)
+
+| Event | Properties | When emitted |
+|---|---|---|
+| `CallAccepted` | `call: Call` | Incoming call accepted |
+| `CallRejected` | `call: Call` | Call rejected |
+
+### 4.3 CometChatUserEvent (sealed class)
+
+User-related events (block, unblock, etc.)
+
+### 4.4 CometChatGroupEvent (sealed class)
+
+Group membership events (member added, removed, scope changed, etc.)
+
+### 4.5 CometChatConversationEvent (sealed class)
+
+Conversation-level events (conversation deleted, etc.)
+
+### 4.6 CometChatUIEvent (sealed class)
+
+UI-level events including `CustomUIPosition` for custom view positioning.
+
+## 5. Migration from v5
+
+| v5 Pattern | v6 Pattern |
+|---|---|
+| `CometChatMessageEvents.addListener(id, listener)` | `CometChatEvents.messageEvents.collect { }` |
+| `CometChatCallEvents.addListener(id, listener)` | `CometChatEvents.callEvents.collect { }` |
+| `listener.onTextMessageSent(message)` | `is CometChatMessageEvent.MessageSent` |
+| `removeListener(id)` | Cancel the coroutine scope |
+| Java interface callbacks | Kotlin sealed class + when expression |
+
+## Hard rules
+
+- NEVER collect flows on `Dispatchers.Default` for UI updates — switch to `Dispatchers.Main` or use `viewModelScope` / `lifecycleScope`
+- ALWAYS cancel coroutine scopes when the component is destroyed to avoid memory leaks
+- Events are emitted on `Dispatchers.Default` — the subscriber is responsible for thread switching
+- Buffer overflow uses `DROP_OLDEST` — high-frequency events may be dropped if the subscriber is slow
+- Do NOT confuse UIKit events (`CometChatEvents`) with SDK-level listeners (`CometChat.addMessageListener`) — they are separate systems
+- `CometChatUIKit.sendTextMessage()` / `sendMediaMessage()` / `sendCustomMessage()` automatically emit message events — do not double-emit

package/skills/cometchat-android-v6-extensions/SKILL.md

@@ -0,0 +1,191 @@
+---
+name: cometchat-android-v6-extensions
+description: "CometChat Android UIKit v6 extension architecture — DataSource/Repository pattern, custom message types, and data-layer overrides"
+license: "MIT"
+compatibility: "Android 9.0+ (API 28); Kotlin 1.9+; com.cometchat:chatuikit-core-android:6.x"
+allowed-tools: "executeBash, readFile, fileSearch, listDirectory"
+metadata:
+  author: "CometChat"
+  version: "3.0.0"
+  tags: "cometchat, android, extensions, datasource, repository, clean-architecture"
+---
+
+> **Companion skills:** cometchat-android-v6-features (feature catalog), cometchat-android-v6-kotlin-customization, cometchat-android-v6-compose-customization
+
+## Purpose
+
+Extend the CometChat UIKit v6 data layer using the clean architecture DataSource/Repository pattern. Create custom DataSource implementations, override repository behavior, and register custom message types.
+
+## Use this skill when
+
+- Creating a custom DataSource implementation to change how data is fetched
+- Overriding default repository behavior
+- Registering custom message types
+- Understanding the data flow from DataSource → Repository → ViewModel
+
+## Do not use this skill when
+
+- Customizing UI/bubble rendering (use `cometchat-*-customization` — that's the BubbleFactory layer)
+- Working with component APIs (use `cometchat-*-components`)
+
+## 1. Clean Architecture Overview
+
+The `chatuikit-core` module follows clean architecture with three layers:
+
+```
+┌─────────────────────────────────────────┐
+│  UI Layer (chatuikit-kotlin / compose)  │
+│  Components observe ViewModel state     │
+├─────────────────────────────────────────┤
+│  ViewModel Layer (core/viewmodel/)      │
+│  Calls use cases / repositories         │
+├─────────────────────────────────────────┤
+│  Domain Layer (core/domain/)            │
+│  Repository interfaces, Use cases       │
+├─────────────────────────────────────────┤
+│  Data Layer (core/data/)                │
+│  DataSource interfaces + impls          │
+│  Repository implementations            │
+└─────────────────────────────────────────┘
+```
+
+## 2. DataSource Pattern
+
+Each feature area has a DataSource interface and default implementation:
+
+```
+core/data/datasource/
+├── ConversationListDataSource.kt       (interface)
+├── ConversationListDataSourceImpl.kt   (default implementation)
+├── MessageListDataSource.kt
+├── MessageListDataSourceImpl.kt
+├── ...
+```
+
+### 2.1 All DataSource Types
+
+| DataSource | Implementation | What it provides |
+|---|---|---|
+| `CallButtonsDataSource` | `CallButtonsDataSourceImpl` | Call button actions |
+| `CallLogsDataSource` | `CallLogsDataSourceImpl` | Call history fetching |
+| `CollaborativeDataSource` | `CollaborativeDataSourceImpl` | Document/whiteboard data |
+| `ConversationListDataSource` | `ConversationListDataSourceImpl` | Conversation list fetching |
+| `GroupMembersDataSource` | `GroupMembersDataSourceImpl` | Group member operations |
+| `GroupsDataSource` | `GroupsDataSourceImpl` | Group list fetching |
+| `MessageComposerDataSource` | `MessageComposerDataSourceImpl` | Composer actions/attachments |
+| `MessageHeaderDataSource` | `MessageHeaderDataSourceImpl` | Header data (name, status) |
+| `MessageInformationDataSource` | `MessageInformationDataSourceImpl` | Read receipts, delivery info |
+| `MessageListDataSource` | `MessageListDataSourceImpl` | Message fetching/pagination |
+| `PollDataSource` | `PollDataSourceImpl` | Poll creation/voting |
+| `ReactionListDataSource` | `ReactionListDataSourceImpl` | Reaction data |
+| `SearchDataSource` | `SearchDataSourceImpl` | Global search |
+| `StickerDataSource` | `StickerDataSourceImpl` | Sticker fetching |
+| `UsersDataSource` | `UsersDataSourceImpl` | User list fetching |
+
+### 2.2 Additional DataSource
+
+| File | Purpose |
+|---|---|
+| `MessageReceiptEventListener.kt` | Listens for receipt events at the data layer |
+
+## 3. Repository Pattern
+
+Repositories in `core/data/repository/` implement domain interfaces from `core/domain/repository/`:
+
+```
+core/data/repository/
+├── CallButtonsRepositoryImpl.kt
+├── CallLogsRepositoryImpl.kt
+├── ConversationListRepositoryImpl.kt
+├── GroupMembersRepositoryImpl.kt
+├── GroupsRepositoryImpl.kt
+├── MessageComposerRepositoryImpl.kt
+├── MessageHeaderRepositoryImpl.kt
+├── MessageInformationRepositoryImpl.kt
+├── MessageListRepositoryImpl.kt
+├── PollRepositoryImpl.kt
+├── ReactionListRepositoryImpl.kt
+├── SearchRepositoryImpl.kt
+├── StickerRepositoryImpl.kt
+├── UsersRepositoryImpl.kt
+```
+
+Each repository wraps a DataSource and adds business logic, caching, or transformation.
+
+## 4. ViewModel Layer
+
+ViewModels in `core/viewmodel/` consume repositories and expose UI state:
+
+```kotlin
+// Example: CometChatConversationsViewModel
+// - Injected via CometChatConversationsViewModelFactory
+// - Exposes StateFlow<ConversationListUIState>
+// - Calls ConversationListRepositoryImpl internally
+```
+
+ViewModel factories in `core/factory/` handle dependency injection:
+
+| Factory | ViewModel |
+|---|---|
+| `CometChatConversationsViewModelFactory` | `CometChatConversationsViewModel` |
+| `CometChatMessageListViewModelFactory` | `CometChatMessageListViewModel` |
+| `CometChatGroupsViewModelFactory` | `CometChatGroupsViewModel` |
+| `CometChatUsersViewModelFactory` | `CometChatUsersViewModel` |
+| `CometChatCallLogsViewModelFactory` | `CometChatCallLogsViewModel` |
+| `CometChatMessageComposerViewModelFactory` | `CometChatMessageComposerViewModel` |
+| `CometChatMessageHeaderViewModelFactory` | `CometChatMessageHeaderViewModel` |
+| `CometChatGroupMembersViewModelFactory` | `CometChatGroupMembersViewModel` |
+| `CometChatMessageInformationViewModelFactory` | `CometChatMessageInformationViewModel` |
+| `CometChatReactionListViewModelFactory` | `CometChatReactionListViewModel` |
+| `CometChatSearchViewModelFactory` | `CometChatSearchViewModel` |
+| `CometChatCallButtonsViewModelFactory` | `CometChatCallButtonsViewModel` |
+| `CometChatCreatePollViewModelFactory` | `CometChatCreatePollViewModel` |
+| `CometChatThreadHeaderViewModelFactory` | `CometChatThreadHeaderViewModel` |
+| `CometChatStickerKeyboardViewModelFactory` | `CometChatStickerKeyboardViewModel` |
+| `CometChatIncomingCallViewModelFactory` | `CometChatIncomingCallViewModel` |
+| `CometChatOutgoingCallViewModelFactory` | `CometChatOutgoingCallViewModel` |
+| `CometChatAIAssistantChatHistoryViewModelFactory` | `CometChatAIAssistantChatHistoryViewModel` |
+
+## 5. UI State Classes
+
+Each ViewModel exposes a sealed UI state from `core/state/`:
+
+| State Class | Used By |
+|---|---|
+| `CallLogsUIState` | Call logs |
+| `MessageListUIState` | Message list |
+| `GroupsUIState` | Groups list |
+| `UsersUIState` | Users list |
+| `GroupMembersUIState` | Group members |
+| `MessageComposerUIState` | Composer |
+| `MessageHeaderUIState` | Header |
+| `MessageInformationUIState` | Message info |
+| `ReactionListUIState` | Reactions |
+| `SearchUIState` | Search |
+| `CallButtonsUIState` | Call buttons |
+| `CreatePollUIState` | Poll creation |
+| `ThreadHeaderUIState` | Thread header |
+| `StickerKeyboardUIState` | Sticker keyboard |
+| `IncomingCallUIState` | Incoming call |
+| `OutgoingCallUIState` | Outgoing call |
+| `ChatHistoryUIState` | AI chat history |
+| `ConversationStarterUIState` | AI conversation starter |
+| `ConversationSummaryUIState` | AI conversation summary |
+| `SmartRepliesUIState` | AI smart replies |
+| `DeleteState` | Delete operations |
+| `UIState` | Base UI state |
+
+## 6. Data Flow
+
+```
+User Action → Component → ViewModel → Repository → DataSource → CometChat SDK
+                                                                      ↓
+UI Update  ← Component ← ViewModel ← StateFlow ← Repository ← SDK Response
+```
+
+## Hard rules
+
+- DataSources are the DATA layer — they fetch and mutate data. Do NOT confuse with BubbleFactory which is the UI rendering layer
+- The v5 `DataSource` decorator / `ChatConfigurator` pattern for bubble customization does NOT exist in v6 — use BubbleFactory instead (see `cometchat-*-customization`)
+- ViewModels are shared across both UI stacks (Kotlin Views and Compose) — they live in `chatuikit-core`
+- Always use the provided ViewModel factories — do not instantiate ViewModels directly

package/skills/cometchat-android-v6-features/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: cometchat-android-v6-features
+description: "CometChat Android UIKit v6 feature catalog — AI features, reactions, polls, stickers, moderation, collaborative, and media features"
+license: "MIT"
+compatibility: "Android 9.0+ (API 28); Kotlin 1.9+; com.cometchat:chatuikit-compose-android:6.x / com.cometchat:chatuikit-kotlin-android:6.x"
+allowed-tools: "executeBash, readFile, fileSearch, listDirectory"
+metadata:
+  author: "CometChat"
+  version: "3.0.0"
+  tags: "cometchat, android, features, ai, reactions, polls, stickers, moderation"
+---
+
+> **Companion skills:** cometchat-android-v6-kotlin-components, cometchat-android-v6-compose-components, cometchat-android-v6-extensions (DataSource pattern), cometchat-android-v6-events
+
+## Purpose
+
+Catalog of all features available in CometChat UIKit v6, how they map to components and DataSources, and how to enable/disable them.
+
+## Use this skill when
+
+- Enabling or disabling specific features (AI, reactions, polls, stickers)
+- Understanding what features are available out of the box
+- Mapping a feature to its component and DataSource
+
+## Do not use this skill when
+
+- Working with component APIs directly (use `cometchat-*-components`)
+- Customizing bubble rendering (use `cometchat-*-customization`)
+
+## 1. AI Features
+
+AI features need an OpenAI API key on the app's AI settings. Enable each one with the CLI in stateless mode (Android projects don't write `.cometchat/state.json`):
+
+```bash
+cometchat apply-feature smart-replies --app-id <your-app-id> --openai-key sk-...
+cometchat apply-feature conversation-summary --app-id <your-app-id>
+cometchat apply-feature conversation-starter --app-id <your-app-id>
+```
+
+The OpenAI key is stored on the app once, so subsequent ai-feature applies don't need `--openai-key` repeated. Requires `cometchat auth login` once per machine.
+
+| Feature | Compose Component | Core DataSource | Description |
+|---|---|---|---|
+| AI Assistant Chat History | `CometChatAIAssistantChatHistory` | — | Shows AI bot conversation history |
+| AI Conversation Starter | Shared element in `presentation/shared/aiconversationstarter/` | — | Suggests conversation starters |
+| AI Conversation Summary | Shared element in `presentation/shared/aiconversationsummary/` | — | Summarizes long conversations |
+| AI Smart Replies | Shared element in `presentation/shared/aismartreplies/` | — | Suggests contextual replies |
+
+AI features integrate with `CometChatMessageList` via the `smartRepliesView` slot and AI-specific parameters.
+
+The `CometChatAIStreamService` in `chatuikit-core` handles streaming AI responses.
+
+## 2. Reactions
+
+| Feature | Component | DataSource | Description |
+|---|---|---|---|
+| Reaction List | `CometChatReactionList` | `ReactionListDataSource` | Shows who reacted with what |
+| Add Reaction | Shared element in `presentation/shared/reaction/` | — | Emoji picker for adding reactions |
+
+Reactions appear in the **footer slot** of message bubbles. Reaction events flow through `CometChatEvents.messageEvents`.
+
+## 3. Polls
+
+| Feature | Component | DataSource | Description |
+|---|---|---|---|
+| Create Poll | `CometChatCreatePoll` (Compose) | `PollDataSource` | Create a new poll |
+| Poll Bubble | Shared element in `presentation/shared/` | `PollDataSourceImpl` | Renders poll in message list |
+
+Polls are custom messages with type `extension_poll`. The `PollRepositoryImpl` handles vote submission.
+
+## 4. Stickers
+
+| Feature | Component | DataSource | Description |
+|---|---|---|---|
+| Sticker Keyboard | `CometChatStickerKeyboard` | `StickerDataSource` | Browse and send stickers |
+| Sticker Bubble | `stickerbubble/` (Kotlin Views) | `StickerDataSourceImpl` | Renders sticker in message list |
+
+Stickers integrate with `CometChatMessageComposer` as an auxiliary input.
+
+## 5. Moderation
+
+| Feature | Component | Description |
+|---|---|---|
+| Report/Flag Message | `CometChatFlagMessageDialog` (Views) / `CometChatFlagMessageDialog` (Compose) | Report inappropriate messages |
+
+Moderation views appear in the **bottom slot** of message bubbles when moderation is enabled.
+
+## 6. Collaborative Features
+
+| Feature | DataSource | Description |
+|---|---|---|
+| Collaborative Document | `CollaborativeDataSource` | Real-time document editing |
+| Collaborative Whiteboard | `CollaborativeDataSourceImpl` | Real-time whiteboard |
+
+## 7. Media Features
+
+| Feature | Component | Description |
+|---|---|---|
+| Image Viewer | `CometChatImageViewerScreen` (Compose) | Full-screen image viewing with zoom |
+| Media Recorder | Shared element in `presentation/shared/mediarecorder/` | Audio/video recording |
+| Inline Audio Recorder | Shared element in `presentation/shared/inlineaudiorecorder/` | In-composer audio recording |
+| Media Selection | Shared element in `presentation/shared/mediaselection/` | Photo/video picker |
+
+## 8. Feature-to-DataSource Mapping
+
+All DataSources live in `chatuikit-core/data/datasource/`:
+
+| DataSource Interface | Implementation | Feature Area |
+|---|---|---|
+| `CallButtonsDataSource` | `CallButtonsDataSourceImpl` | Audio/video call buttons |
+| `CallLogsDataSource` | `CallLogsDataSourceImpl` | Call history |
+| `CollaborativeDataSource` | `CollaborativeDataSourceImpl` | Documents/whiteboards |
+| `ConversationListDataSource` | `ConversationListDataSourceImpl` | Conversation list |
+| `GroupMembersDataSource` | `GroupMembersDataSourceImpl` | Group member management |
+| `GroupsDataSource` | `GroupsDataSourceImpl` | Group list |
+| `MessageComposerDataSource` | `MessageComposerDataSourceImpl` | Message input |
+| `MessageHeaderDataSource` | `MessageHeaderDataSourceImpl` | Chat header |
+| `MessageInformationDataSource` | `MessageInformationDataSourceImpl` | Message info/receipts |
+| `MessageListDataSource` | `MessageListDataSourceImpl` | Message list |
+| `PollDataSource` | `PollDataSourceImpl` | Polls |
+| `ReactionListDataSource` | `ReactionListDataSourceImpl` | Reactions |
+| `SearchDataSource` | `SearchDataSourceImpl` | Global search |
+| `StickerDataSource` | `StickerDataSourceImpl` | Stickers |
+| `UsersDataSource` | `UsersDataSourceImpl` | User list |
+
+## Hard rules
+
+- AI features require dashboard configuration — they cannot be enabled purely from client code
+- Polls and stickers are custom message types — they require the corresponding extensions enabled on the dashboard
+- Do NOT confuse DataSources (data layer in core) with BubbleFactory (UI layer in kotlin/compose) — DataSources fetch data, BubbleFactories render bubbles