@cometchat/skills 4.3.0 → 4.4.1

package/skills/cometchat-android-v6-kotlin-customization/SKILL.md

@@ -3,13 +3,14 @@ name: cometchat-android-v6-kotlin-customization
 description: "CometChat Android UIKit v6 Kotlin Views customization — BubbleFactory abstract class, BubbleViewProvider, style classes, and per-slot overrides"
 license: "MIT"
 compatibility: "Android 9.0+ (API 28); Kotlin 1.9+; com.cometchat:chatuikit-kotlin-android:6.x"
-allowed-tools: "shell, file-read, file-search, file-list"
 metadata:
   author: "CometChat"
   version: "3.0.0"
   tags: "cometchat, android, kotlin-views, customization, bubble-factory, bubble-view-provider, style"
 ---
 
+> **Ground truth:** `com.cometchat:chatuikit-{compose,kotlin}-android:6.x` (+ `calls-sdk-android:5.x`) — resolved AAR (javap) + `ui-kit/android/v6`. **Official docs:** https://www.cometchat.com/docs/ui-kit/android/v6/overview · **Docs MCP:** `claude mcp add --transport http cometchat-docs https://www.cometchat.com/docs/mcp` (or fetch the URL directly without MCP). Verify symbols against the installed package/source before relying on them.
+
 > **Companion skills:** cometchat-android-v6-compose-customization (Compose equivalent), cometchat-android-v6-kotlin-components, cometchat-android-v6-kotlin-theming, cometchat-android-v6-extensions (DataSource layer), cometchat-android-v6-events
 
 ## Purpose
@@ -156,6 +157,157 @@ val key = BubbleFactory.getFactoryKey(message) // "category_type" or "deleted"
 val key = BubbleFactory.getKey("custom", "location") // "custom_location"
 ```
 
+### 1.8 Registering a factory is already additive — built-ins are NOT in the map
+
+`CometChatMessageList` exposes exactly two factory APIs (`CometChatMessageList.kt:3376 / :3395`):
+
+- `setBubbleFactories(factories: List<BubbleFactory>)` — sets the custom factory map
+- `getBubbleFactories(): Map<String, BubbleFactory>` — returns an immutable copy
+
+There is **NO** settable `bubbleFactories` property and **NO** `removeBubbleFactory(...)` on `CometChatMessageList` (`removeBubbleFactory` exists only on the internal `MessageAdapter`, `MessageAdapter.kt:1534` — not public API).
+
+`setBubbleFactories` does NOT wipe built-in bubbles, because **built-in types are never stored as factory entries.** The adapter starts with an empty factory map (`MessageAdapter.kt:153` "The adapter starts with an empty bubbleFactories map"); when a message's `"category_type"` key has no factory, the bubble falls back to `InternalContentRenderer`. So passing only your custom factories is correct and safe:
+
+```kotlin
+messageList.setBubbleFactories(listOf(
+    LocationBubbleFactory(),     // custom_location
+    PaymentBubbleFactory()       // custom_payment
+))
+// text/image/video/etc. still render via InternalContentRenderer — untouched
+```
+
+`setBubbleFactories` replaces the *custom* factory set, so include every custom factory you want active in the single list. `BubbleFactory.getKey(category, type)` and `BubbleFactory.getFactoryKey(message)` (companion, `BubbleFactory.kt:441 / :425`) are still available if you need the key string.
+
+### 1.9 Custom attachment options (Scenario 3)
+
+`CometChatMessageComposer` exposes `addAttachmentOption(action)` (append one) and `setAttachmentOptions(list)` (set the custom list) — `CometChatMessageComposer.kt:4951 / :4930`, both delegate to the shared `CometChatMessageComposerViewModel`.
+
+**Neither call drops the built-in options.** Both touch only the *custom* options list (`_customAttachmentOptions`); the defaults (camera/image/video/audio/document/poll/collab-doc/collab-whiteboard) are rebuilt every time by `getDefaultAttachmentOptions(...)` and the custom ones are appended at the end (`CometChatMessageComposerViewModel.kt:646-649`). So `setAttachmentOptions(listOf(location))` keeps the defaults too — it just replaces any *previously-set custom* options. Use `addAttachmentOption` to add one without disturbing other custom options:
+
+```kotlin
+val location = CometChatMessageComposerAction(
+    id = "location",
+    title = "Send Location",
+    icon = R.drawable.ic_location,
+    onClick = OnClick { /* pick + send (see 1.10) */ }
+)
+messageComposer.addAttachmentOption(location)        // appends one custom option
+// setAttachmentOptions(listOf(location)) also keeps camera/image/etc. — it only resets the custom list
+```
+
+> To hide a built-in option, use the composer visibility setters (e.g. `setPollOptionVisibility(View.GONE)`), which flip the `_show*Option` flags `getDefaultAttachmentOptions` checks. The built-in IDs are constants on `CometChatMessageComposerAction` (`ID_CAMERA`…`ID_COLLABORATIVE_WHITEBOARD`, `CometChatMessageComposerAction.kt:42-49`).
+
+### 1.10 Sending a custom message — use the UIKit path, not the raw SDK
+
+```kotlin
+val message = CustomMessage(
+    receiverId,
+    CometChatConstants.RECEIVER_TYPE_USER,   // or RECEIVER_TYPE_GROUP
+    "location",                              // matches the BubbleFactory type
+    customData                               // org.json.JSONObject
+)
+// ✅ kit path — sets muid + sender, fires ccMessageSent → list APPENDS
+CometChatUIKit.sendCustomMessage(message, object : CometChat.CallbackListener<CustomMessage>() {
+    override fun onSuccess(p0: CustomMessage) {}
+    override fun onError(p0: CometChatException) {}
+})
+// ❌ CometChat.sendCustomMessage(...) — no muid/sender/event → recipient error + realtime replace
+```
+
+Verified (v6 Kotlin Views): `CometChatMessageList.setBubbleFactories(List) / getBubbleFactories(): Map` (`CometChatMessageList.kt:3376 / :3395`), `CometChatMessageComposer.addAttachmentOption / setAttachmentOptions` (`:4951 / :4930`), `CometChatUIKit.sendCustomMessage(CustomMessage, CallbackListener)` (`CometChatUIKit.kt:472`). Note: `messageList.bubbleFactories = …` (property) and `CometChatMessageList.removeBubbleFactory(...)` are NOT public — do not use.
+
+### 1.11 Override an EXISTING type's bubble (Scenario 2)
+
+To replace a built-in type's rendering, subclass `BubbleFactory` with `getCategory()`/`getType()` set to the built-in identifiers, then register it. As in §1.8, built-ins are not factory entries — a matching factory simply takes priority over `InternalContentRenderer`.
+
+```kotlin
+import com.cometchat.chat.constants.CometChatConstants
+
+class MyTextBubbleFactory : BubbleFactory() {
+    override fun getCategory(): String = CometChatConstants.CATEGORY_MESSAGE   // "message"
+    override fun getType(): String = CometChatConstants.MESSAGE_TYPE_TEXT      // "text"
+
+    override fun createContentView(context: Context): View = MyTextContentView(context)
+
+    override fun bindContentView(
+        view: View,
+        message: BaseMessage,
+        alignment: UIKitConstants.MessageBubbleAlignment,
+        holder: RecyclerView.ViewHolder?,
+        position: Int
+    ) {
+        (view as MyTextContentView).bind(message as TextMessage)
+    }
+    // …or override createBubbleView()/bindBubbleView() (see 1.3) to replace the whole bubble
+}
+
+messageList.setBubbleFactories(listOf(MyTextBubbleFactory()))
+```
+
+Only `message_text` is overridden; other types keep their internal rendering.
+
+### 1.12 Add a long-press message option (Scenario 4 — Forward-style)
+
+`CometChatMessageList` resolves the long-press option sheet through the shared view model. Two public setters control it (`CometChatMessageList.kt:3697 / :3709`):
+
+- `setOptions(callback: (BaseMessage) -> List<CometChatMessageOption>?)` — **replaces** defaults when the callback returns non-null (return `null` to keep them); takes precedence over `addOptions`.
+- `addOptions(callback: (BaseMessage) -> List<CometChatMessageOption>)` — **appends** after the defaults; invoked only when `setOptions` is unset or returns `null`.
+
+Use `addOptions` so the built-in Reply/Copy/Edit/Delete survive:
+
+```kotlin
+import com.cometchat.uikit.core.domain.model.CometChatMessageOption
+
+messageList.addOptions { message ->          // ✅ appended to defaults
+    listOf(
+        CometChatMessageOption(
+            id = "forward",
+            title = "Forward",
+            icon = R.drawable.ic_forward,
+            onClick = { /* open forward picker for `message` */ }
+        )
+    )
+}
+// ❌ messageList.setOptions { listOf(forward) }   // would DROP reply/copy/edit/delete
+```
+
+For the click handler use `setMessageOptionClickListener(MessageOptionClickListener)` (`CometChatMessageList.kt:3671`). Resolution order verified in `CometChatMessageListViewModel.resolveMessageOptions` (`:817-827`): `setOptions` non-null wins, else `defaultOptions + addOptions`. `CometChatMessageOption(id, title, …, onClick)` is a data class at `CometChatMessageOption.kt:21`.
+
+### 1.13 MessageTemplate via the DataSource (docs-taught alternative to BubbleFactory)
+
+> ⚠️ **Verify before using — symbols not found in the GA v6 Kotlin-Views source.** `CometChatUIKit.getDataSource()`, `getMessageTemplates()`, `CometChatMessageTemplate`, `setTemplates(...)`, and `MessagesViewHolderListener` appear in the Android **docs** but are **absent from the verified `com.cometchat.uikit.kotlin` / `chatuikit-core` GA source** (they're the legacy `com.cometchat.chatuikit` v5-shaped API). Treat this section as a docs reference that may not compile against your installed v6 kit — **prefer `BubbleFactory` / `BubbleViewProvider` (the confirmed v6-native path) for all new code.**
+
+The `BubbleFactory` / `BubbleViewProvider` surface above is the primary v6 customization path. The Android docs also teach a **`MessageTemplate`** path through the data source ([message-template](https://www.cometchat.com/docs/ui-kit/android/v6/message-template)) — fetch the existing templates, mutate the one you want via the `MessagesViewHolderListener` create/bind pair, then re-apply with `setTemplates(...)` (append, never replace with a single-item list):
+
+```kotlin
+// 1. fetch existing templates from the data source
+val templates = CometChatUIKit.getDataSource()
+    .getMessageTemplates(messageList.additionParameter)
+    .toMutableList()
+
+// 2. mutate the matched template (or build a new one for a custom type)
+templates.find { it.type == UIKitConstants.MessageType.TEXT }
+    ?.setContentView(object : MessagesViewHolderListener() {
+        override fun createView(context: Context, bubble: CometChatMessageBubble,
+            alignment: UIKitConstants.MessageBubbleAlignment): View =
+            LayoutInflater.from(context).inflate(R.layout.your_custom_layout, null)
+        override fun bindView(context: Context, view: View, message: BaseMessage,
+            alignment: UIKitConstants.MessageBubbleAlignment,
+            viewHolder: RecyclerView.ViewHolder, list: List<BaseMessage>, i: Int) { /* bind */ }
+    })
+// new custom type:
+val contact = CometChatMessageTemplate().apply {
+    setType("contact"); setCategory(UIKitConstants.MessageCategory.CUSTOM)
+    setContentView(/* MessagesViewHolderListener */)
+}
+templates.add(contact)
+
+// 3. re-apply — Views uses setTemplates(...)
+messageList.setTemplates(templates)
+```
+
+Views templates expose listener-based slot setters (`setContentView`, `setHeaderView`, `setFooterView`, `setBottomView`, `setStatusInfoView`, `setBubbleView`, `setOptions`) mirroring §1.4's slots. Prefer `BubbleFactory` for new code; use `getMessageTemplates(...)` + `setTemplates(...)` when you want to start from the kit's defaults and tweak one type. (This overlaps the custom-message topic.)
+
 ## 2. BubbleViewProvider (Per-Slot Overrides)
 
 `BubbleViewProvider` is a simpler interface for overriding individual slots across ALL message types.
@@ -257,6 +409,21 @@ messageList.setStyle(style)
 | No bubble replacement | `createBubbleView()` for complete replacement |
 | Theme-level styling only | Per-factory `getBubbleStyle()` |
 
+## Text formatters (inline mentions / URLs / custom tokens)
+
+Style/transform message text inline via `setTextFormatters(...)` on the composer and message list. The kit ships `CometChatMentionsFormatter` + `CometChatRichTextFormatter` (subclasses of the abstract `CometChatTextFormatter`) in `com.cometchat.uikit.kotlin.shared.formatters`. To ADD a custom one, include the defaults too (a bare list replaces them).
+
+```kotlin
+import com.cometchat.uikit.kotlin.shared.formatters.CometChatMentionsFormatter
+import com.cometchat.uikit.kotlin.shared.formatters.CometChatTextFormatter
+
+val formatters = listOf<CometChatTextFormatter>(CometChatMentionsFormatter(context) /* , YourFormatter(context) */)
+composer.setTextFormatters(formatters)      // fun setTextFormatters(List<CometChatTextFormatter>?)
+messageList.setTextFormatters(formatters)
+```
+
+For a custom @/#/! token: subclass `CometChatTextFormatter(trackingCharacter)` and implement its `search()` + view hooks (the kit's `shared/formatters/README.md` shows the mentions example: `setMentionLimit` / `setMentionsType` / `setOnMentionClick` / `setMentionStyle`).
+
 ## Hard rules
 
 - BubbleFactory is an `abstract class` — extend it with `BubbleFactory()`
@@ -266,3 +433,7 @@ messageList.setStyle(style)
 - For per-type content customization, use BubbleFactory. For cross-type slot overrides, use BubbleViewProvider
 - `onViewRecycled()` is critical for cleaning up image loads, animations, or media playback
 - Do NOT confuse BubbleFactory (UI rendering) with DataSource (data fetching) — they are separate layers
+
+## Sound (in-app message + call sounds)
+
+Sound is a customization sub-dimension. The UI Kit plays incoming/outgoing message + call sounds via `CometChatSoundManager` — mute it, swap custom audio, or play a specific sound. The full API + recipe lives in **`cometchat-android-v6-kotlin-theming`** (Sound section). Verify the access path against the installed kit before relying on it.

package/skills/cometchat-android-v6-kotlin-placement/SKILL.md

@@ -3,18 +3,19 @@ name: cometchat-android-v6-kotlin-placement
 description: "CometChat Android UIKit v6 Kotlin Views placement — Activity, Fragment, BottomSheet, Tab, and Intent navigation patterns"
 license: "MIT"
 compatibility: "Android 9.0+ (API 28); Kotlin 1.9+; com.cometchat:chatuikit-kotlin-android:6.x"
-allowed-tools: "shell, file-read, file-search, file-list"
 metadata:
   author: "CometChat"
   version: "3.0.1"
   tags: "cometchat, android, kotlin-views, placement, activity, fragment, navigation, tabs"
 ---
 
+> **Ground truth:** `com.cometchat:chatuikit-kotlin-android:6.x` Views + `docs/ui-kit/android/v6`. **Official docs:** https://www.cometchat.com/docs/ui-kit/android/v6/overview · **Docs MCP:** `claude mcp add --transport http cometchat-docs https://www.cometchat.com/docs/mcp` (or fetch the URL directly without MCP). Verify symbols against the installed package/source before relying on them.
+
 > **Companion skills:** cometchat-android-v6-compose-placement (Compose equivalent), cometchat-android-v6-kotlin-components, cometchat-android-v6-kotlin-theming
 
 ## Purpose
 
-Place CometChat Kotlin Views components into Activities, Fragments, BottomSheets, and Tab layouts. Patterns derived from `master-app-kotlin`.
+Place CometChat Kotlin Views components into Activities, Fragments, BottomSheets, and Tab layouts. Patterns derived from `sample-app-kotlin`.
 
 ## Use this skill when
 
@@ -50,7 +51,7 @@ class ConversationsActivity : AppCompatActivity() {
 
 ### 1.2 Messages Activity
 
-Pattern from `master-app-kotlin/appflow/MessagesActivity.kt`:
+Pattern from `sample-app-kotlin/.../ui/messages/MessagesActivity.kt`:
 
 ```kotlin
 class MessagesActivity : AppCompatActivity() {
@@ -58,10 +59,21 @@ class MessagesActivity : AppCompatActivity() {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_messages)
 
+        // Pad the root for the status/navigation bars (root has fitsSystemWindows="true").
+        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.parent_view)) { view, insets ->
+            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+            view.setPadding(systemBars.left, systemBars.top, systemBars.right, 0)
+            insets
+        }
+
         val header = findViewById<CometChatMessageHeader>(R.id.messageHeader)
         val messageList = findViewById<CometChatMessageList>(R.id.messageList)
         val composer = findViewById<CometChatMessageComposer>(R.id.messageComposer)
 
+        // Show + wire the back button (the kit does not finish the Activity for you).
+        header.setBackButtonVisibility(View.VISIBLE)
+        header.setOnBackPress { finish() }
+
         // Set user or group
         header.setUser(user)
         messageList.setUser(user)
@@ -75,13 +87,16 @@ class MessagesActivity : AppCompatActivity() {
 }
 ```
 
-XML layout:
+XML layout — the root carries `android:fitsSystemWindows="true"` (so the inset listener above receives system-bar insets) and `?attr/cometchatBackgroundColor1`:
 
 ```xml
 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/parent_view"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
+    android:background="?attr/cometchatBackgroundColor1"
+    android:fitsSystemWindows="true"
     android:orientation="vertical">
 
     <com.cometchat.uikit.kotlin.presentation.messageheader.ui.CometChatMessageHeader
@@ -192,7 +207,7 @@ dialog.show()
 
 ## 6. App Flow Pattern
 
-From `master-app-kotlin/appflow/DefaultComponentAppFlowActivity.kt` — a single Activity hosts the full chat flow with Fragment transactions:
+Pattern from `sample-app-kotlin/.../ui/home/HomeActivity.kt` — a single Activity hosts the chat flow via Fragment transactions:
 
 ```kotlin
 class AppFlowActivity : AppCompatActivity() {

package/skills/cometchat-android-v6-kotlin-theming/SKILL.md

@@ -3,13 +3,14 @@ name: cometchat-android-v6-kotlin-theming
 description: "CometChat Android UIKit v6 Kotlin Views theming — CometChatTheme singleton, XML attributes, programmatic overrides, typography, and dark mode"
 license: "MIT"
 compatibility: "Android 9.0+ (API 28); Kotlin 1.9+; com.cometchat:chatuikit-kotlin-android:6.x"
-allowed-tools: "shell, file-read, file-search, file-list"
 metadata:
   author: "CometChat"
   version: "3.0.0"
   tags: "cometchat, android, kotlin-views, theming, xml-attrs, colors, typography, dark-mode"
 ---
 
+> **Ground truth:** `com.cometchat:chatuikit-{compose,kotlin}-android:6.x` (+ `calls-sdk-android:5.x`) — resolved AAR (javap) + `ui-kit/android/v6`. **Official docs:** https://www.cometchat.com/docs/ui-kit/android/v6/overview · **Docs MCP:** `claude mcp add --transport http cometchat-docs https://www.cometchat.com/docs/mcp` (or fetch the URL directly without MCP). Verify symbols against the installed package/source before relying on them.
+
 > **Companion skills:** cometchat-android-v6-compose-theming (Compose equivalent), cometchat-android-v6-kotlin-components, cometchat-android-v6-kotlin-customization
 
 ## Purpose
@@ -47,10 +48,14 @@ CometChatTheme.setErrorColor(Color.RED)
 
 ## 2. XML Theme Attributes
 
-Define theme colors in your app's `styles.xml` or `themes.xml`:
+> **The app/activity theme MUST extend `CometChatTheme.DayNight` (required — components crash without it).** The kit ships `CometChatTheme.DayNight` (parent `Theme.MaterialComponents.DayNight.NoActionBar`), which defines every `cometchat*` theme attribute the component layouts reference. Parenting a plain `Theme.MaterialComponents` / `Theme.Material3` / `Theme.AppCompat` instead leaves those attrs unresolved and the **first component inflate crashes** — e.g. `CometChatConversations` (which inflates a `MaterialButton`/`MaterialCardView`) throws `java.lang.UnsupportedOperationException: Failed to resolve attribute …` or `IllegalArgumentException: requires your app theme to be Theme.MaterialComponents`. Set it in `AndroidManifest.xml` via `android:theme="@style/AppTheme"` (or `android:theme="@style/CometChatTheme.DayNight"` directly). Verified by building + running on-device, 2026-06-11.
+
+Define theme colors in your app's `styles.xml` or `themes.xml`, parenting the kit theme:
 
 ```xml
-<style name="AppTheme" parent="Theme.MaterialComponents.DayNight">
+<!-- parent MUST be CometChatTheme.DayNight (or a descendant) -->
+<style name="AppTheme" parent="CometChatTheme.DayNight">
+    <!-- Override only what you want; the parent supplies all defaults. -->
     <!-- Primary -->
     <item name="cometchatPrimaryColor">#6851D6</item>
 
@@ -129,7 +134,7 @@ Extended primary colors auto-generate by blending primary with white (day) or bl
 
 All follow the same pattern: `get{Token}(ctx)` / `set{Token}(color)` / `cometchat{Token}` XML attr. Defaults fall back to neutral scale values if not explicitly set.
 
-Border color aliases: `getBorderColorLight()` = `getStrokeColorLight()`, etc.
+Border color aliases: `getBorderColorLight()` = `getStrokeColorLight()`, `getBorderColorDefault()` = `getStrokeColorDefault()`, `getBorderColorDark()` = `getStrokeColorDark()`. Note: `StrokeColor` also has a `Highlight` variant (`getStrokeColorHighlight()`); there is **no** `getBorderColorHighlight()`.
 
 ## 4. Typography
 
@@ -138,7 +143,8 @@ Border color aliases: `getBorderColorLight()` = `getStrokeColorLight()`, etc.
 val titleBold: Int = CometChatTheme.getTextAppearanceTitleBold(context)
 val bodyRegular: Int = CometChatTheme.getTextAppearanceBodyRegular(context)
 val heading1Medium: Int = CometChatTheme.getTextAppearanceHeading1Medium(context)
-// ... all combinations: Title, Heading1-4, Body, Caption1-2, Button, Link × Regular/Medium/Bold
+// ... combinations: Title, Heading1-4, Body, Caption1-2, Button each have Regular/Medium/Bold.
+// Link is the exception — only getTextAppearanceLinkRegular(context) exists (no Medium/Bold).
 
 // Get font resource IDs
 val regularFont: Int = CometChatTheme.getFontRegular(context)
@@ -193,6 +199,31 @@ val black: Int = CometChatTheme.getColorBlack(context)
 val transparent: Int = CometChatTheme.getColorTransparent(context)
 ```
 
+## Localization
+
+To translate the UI, switch the active language, or override individual strings, route to the dedicated **`cometchat-i18n`** skill — the canonical cross-family localization reference. Android uses `CometChatLocalize.setLocale(context, Language.Code.<lang>)` / `getLocale(context)` (a separate method, **not** an `init` object — unlike web/RN). `cometchat-i18n` covers bundled languages, custom translations, and RTL. Docs: https://www.cometchat.com/docs/ui-kit/android/localize
+
+## Sound Manager — custom notification & call sounds
+
+Sounds are a **behavioral** customization — driven by `CometChatSoundManager`, an **instance** class that needs a `Context`. The UI Kit plays the built-in cues automatically; use this to override a cue with your own raw resource. V6 package (NOT the V5 `com.cometchat.chatuikit.*` path):
+
+```kotlin
+import com.cometchat.uikit.core.resources.soundmanager.CometChatSoundManager
+import com.cometchat.uikit.core.resources.soundmanager.Sound
+
+val soundManager = CometChatSoundManager(context)
+
+// Play a default cue — Sound enum is SCREAMING_SNAKE_CASE: INCOMING_CALL |
+//   OUTGOING_CALL | INCOMING_MESSAGE | INCOMING_MESSAGE_FROM_OTHER | OUTGOING_MESSAGE
+soundManager.play(Sound.INCOMING_CALL)
+
+// Override with your own raw resource (R.raw.*)
+soundManager.play(Sound.INCOMING_MESSAGE, R.raw.my_ping)
+
+// Stop whatever is playing
+soundManager.pause()
+```
+
 ## Hard rules
 
 - ALWAYS pass a valid `Context` to getter methods — they resolve XML attributes from the theme

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

@@ -1,9 +1,8 @@
 ---
 name: cometchat-android-v6-migration
-description: V5→V6 migration recipes for native Android. CometChat ships V5 (chat-uikit-android:5.x — Java + Kotlin Views) and V6 beta (chatuikit-{compose,kotlin}-android:6.x — Compose surface OR Kotlin Views, calls bundled) side-by-side. Covers when to migrate vs stay, the cohort-selection decision (Compose vs Kotlin Views on V6), gradle dependency rewrites, builder API changes (UIKitSettings replaces UIKitSettingsBuilder), theme system rewrite (CometChatTheme.DayNight), calls integration delta (calls bundled — drop calls-sdk-android), Activity theme rules, side-by-side cohort selection during migration, and a verification checklist.
+description: V5→V6 migration recipes for native Android. CometChat ships V5 (chat-uikit-android:5.x — Java + Kotlin Views) and V6 (chatuikit-{compose,kotlin}-android:6.x — GA 2026-05-25 — Compose surface OR Kotlin Views, calls bundled) side-by-side. Covers when to migrate vs stay, the cohort-selection decision (Compose vs Kotlin Views on V6), gradle dependency rewrites, builder API changes (UIKitSettings replaces UIKitSettingsBuilder), theme system rewrite (CometChatTheme.DayNight), calls integration delta (calling UI bundled, but calls-sdk-android:5.0.+ is still a required peer dep), Activity theme rules, side-by-side cohort selection during migration, and a verification checklist.
 license: "MIT"
-compatibility: "Migrating FROM com.cometchat:chat-uikit-android:5.x TO com.cometchat:chatuikit-{compose,kotlin}-android:6.0.0-beta2; minSdk 28+ (V6 raised the floor from 21 to 28); Kotlin >= 1.9 for V6 Compose"
-allowed-tools: "shell, file-read, file-search, file-list, ask-user"
+compatibility: "Migrating FROM com.cometchat:chat-uikit-android:5.x TO com.cometchat:chatuikit-{compose,kotlin}-android:6.0.+; minSdk 28+ (V6 raised the floor from 21 to 28); Kotlin >= 1.9 for V6 Compose"
 metadata:
   author: "CometChat"
   version: "4.0.0"
@@ -12,7 +11,7 @@ metadata:
 
 ## Purpose
 
-Migration recipes for moving from CometChat Android UIKit V5 (`chat-uikit-android:5.x`) to V6 (`chatuikit-{compose,kotlin}-android:6.0.0-beta2`). V6 is stable (GA 2026-05-25) — most production apps should stay on V5 today; this skill is for teams evaluating V6 or planning the eventual migration.
+Migration recipes for moving from CometChat Android UIKit V5 (`chat-uikit-android:5.x`) to V6 (`chatuikit-{compose,kotlin}-android:6.0.+`). V6 is stable (GA 2026-05-25) and the recommended target for new apps; existing V5 apps can migrate when ready — there's no forced timeline, and V5 remains supported. This skill covers both the decision and the mechanics.
 
 V6 is a different SDK, not a drop-in replacement. The migration is roughly the size of jumping from React Native UIKit v5 to v6 — package coordinates, builder APIs, theme system, calls handling all change.
 
@@ -23,9 +22,9 @@ V6 is a different SDK, not a drop-in replacement. The migration is roughly the s
 - `cometchat-android-v6-{compose,kotlin}-{components,placement,theming,customization}` — surface-specific destination skills
 - `cometchat-android-v6-calls` — calls migration (calls SDK is bundled in V6)
 
-**Ground truth:**
+**Ground truth:** **Official docs:** https://www.cometchat.com/docs/ui-kit/android/v6/overview · **Docs MCP:** `claude mcp add --transport http cometchat-docs https://www.cometchat.com/docs/mcp` (or fetch the URL directly without MCP).
 - V5 source — installed `com.cometchat:chat-uikit-android@5.x` artifacts under `~/.gradle/caches/`
-- V6 source — installed `chatuikit-{compose,kotlin}-android@6.0.0-beta2` artifacts
+- V6 source — installed `chatuikit-{compose,kotlin}-android@6.0.+` artifacts
 - Sister skill — `cometchat-flutter-v6-migration` (different platform, same migration shape)
 
 ---
@@ -44,7 +43,7 @@ V6 is a different SDK, not a drop-in replacement. The migration is roughly the s
 - You're starting a new project
 - You're rewriting your existing app's UI to Compose anyway
 - You need V6 features that aren't backported to V5 (e.g. some AI Agent components)
-- You've validated V6 beta against your use cases on a sample project first
+- You've validated V6 against your use cases on a sample project first
 
 **The dispatcher (`cometchat-android-v6`) routes by detected version.** Both V5 and V6 skill sets ship in `npx @cometchat/skills add --family android` — the migration here lives under V6 because that's the destination cohort.
 
@@ -56,8 +55,8 @@ V6 is split into two surfaces:
 
 | Surface | Package | When to pick |
 |---|---|---|
-| Compose | `com.cometchat:chatuikit-compose-android:6.0.0-beta2` | New apps; existing apps already on Compose |
-| Kotlin Views | `com.cometchat:chatuikit-kotlin-android:6.0.0-beta2` | Existing apps on Java + XML layouts; teams not ready for Compose |
+| Compose | `com.cometchat:chatuikit-compose-android:6.0.+` | New apps; existing apps already on Compose |
+| Kotlin Views | `com.cometchat:chatuikit-kotlin-android:6.0.+` | Existing apps on Java + XML layouts; teams not ready for Compose |
 
 **You can mix both in the same app**, but a single chat surface is one or the other — not both.
 
@@ -81,7 +80,7 @@ dependencies {
 
 ```kotlin
 dependencies {
-  implementation("com.cometchat:chatuikit-compose-android:6.0.0-beta2")
+  implementation("com.cometchat:chatuikit-compose-android:6.0.+")
   // No separate calls SDK — calls bundled into the same artifact
   // Compose dependencies (if not already present)
   implementation(platform("androidx.compose:compose-bom:2024.02.00"))
@@ -95,7 +94,7 @@ dependencies {
 
 ```kotlin
 dependencies {
-  implementation("com.cometchat:chatuikit-kotlin-android:6.0.0-beta2")
+  implementation("com.cometchat:chatuikit-kotlin-android:6.0.+")
   // No separate calls SDK
   // Material Components for theming (`CometChatTheme.DayNight` extends Material themes)
   implementation("com.google.android.material:material:1.11.+")
@@ -135,30 +134,28 @@ CometChatUIKit.init(this, settings, object : CometChat.CallbackListener<String>(
 })
 ```
 
-### V6 — `UIKitSettings.Builder()`
+### V6 — `UIKitSettings.UIKitSettingsBuilder()`
 
 ```kotlin
-val settings = UIKitSettings.Builder()
+val settings = UIKitSettings.UIKitSettingsBuilder()
   .setAppId(BuildConfig.COMETCHAT_APP_ID)
   .setRegion(BuildConfig.COMETCHAT_REGION)
   .setAuthKey(BuildConfig.COMETCHAT_AUTH_KEY)
   .subscribePresenceForAllUsers()
-  .enableCalling()                                // ← calls toggled on here, not via separate SDK
+  .setEnableCalling(true)                         // ← calls toggled on here, not via separate SDK
   .build()
 
-CometChatUIKit.init(this, settings) { result ->
-  when (result) {
-    is CometChatUIKit.Result.Success -> { /* ... */ }
-    is CometChatUIKit.Result.Error   -> { /* surface to UI */ }
-  }
-}
+CometChatUIKit.init(this, settings, object : CometChat.CallbackListener<String>() {
+  override fun onSuccess(result: String) { /* ... */ }
+  override fun onError(e: CometChatException) { /* surface to UI */ }
+})
 ```
 
 Differences:
 
-- Class name: `UIKitSettingsBuilder` → `UIKitSettings.Builder()`
-- Calls: separate SDK init → `.enableCalling()` flag
-- Result: `CallbackListener` → `Result.Success` / `Result.Error` sealed class
+- Builder: unchanged — both V5 and V6 use `UIKitSettings.UIKitSettingsBuilder()` (nested class)
+- Calls: separate SDK init → `.setEnableCalling(true)` flag on the builder
+- Result handling: unchanged — `init()`/`login()` still take `CometChat.CallbackListener<T>` (onSuccess/onError). There is **no** `Result.Success`/`Result.Error` sealed class in V6.
 
 For full builder option mapping, see `cometchat-android-v6-builder-settings`.
 
@@ -166,7 +163,7 @@ For full builder option mapping, see `cometchat-android-v6-builder-settings`.
 
 ## 5. Calls integration migration
 
-V5 has a separate `calls-sdk-android` artifact + a separate `CometChatCalls.init`. V6 bundles calls into `chatuikit-{compose,kotlin}-android` and toggles via `.enableCalling()`.
+V5 has a separate `calls-sdk-android` artifact + a separate `CometChatCalls.init`. V6 bundles calls into `chatuikit-{compose,kotlin}-android` and toggles via `.setEnableCalling(true)`.
 
 ### V5 calls init
 
@@ -184,12 +181,17 @@ CometChatCalls.init(this, callAppSettings, /* callback */)
 ### V6 calls init
 
 ```kotlin
-val settings = UIKitSettings.Builder()
+val settings = UIKitSettings.UIKitSettingsBuilder()
   // ... appId, region, authKey ...
-  .enableCalling()              // ← that's it; calls SDK init happens internally
+  .setEnableCalling(true)              // ← that's it; calls SDK init happens internally
   .build()
 
-CometChatUIKit.init(this, settings) { /* ... */ }
+// init takes a CometChat.CallbackListener<String> (an abstract class — NOT a
+// fun interface), so use the object form, not a trailing lambda.
+CometChatUIKit.init(this, settings, object : CometChat.CallbackListener<String>() {
+  override fun onSuccess(result: String) { /* ready */ }
+  override fun onError(e: CometChatException) { /* handle */ }
+})
 ```
 
 ### Permissions + manifest carry over
@@ -255,7 +257,7 @@ This is documented in `cometchat-android-v6-troubleshooting` and surfaced in the
 1. Audit V5 theme attrs (`grep cometchat res/values/`)
 2. Map each to its V6 equivalent (most are same names; some have been renamed for Material 3 alignment)
 3. Activity manifest: change `android:theme="@style/Theme.AppCompat.*"` → `android:theme="@style/Theme.YourApp"` where the new theme inherits `CometChatTheme.DayNight`
-4. Programmatic theme overrides: rewrite via Compose `CometChatTheme(colorScheme = ...)` or Kotlin Views `CometChatTheme.singleton.colors.primary = ...` (depending on surface)
+4. Programmatic theme overrides: rewrite via Compose `CometChatTheme(colorScheme = ...)` or Kotlin Views `CometChatTheme.setPrimaryColor(...)` (the `CometChatTheme` object exposes `setPrimaryColor`/`setExtendedPrimaryColor*`/`setNeutralColor*` etc. — there is no `.singleton.colors` field; depends on surface)
 
 For full mapping, see `cometchat-android-v6-{compose,kotlin}-theming`.
 
@@ -275,24 +277,24 @@ import com.cometchat.chatuikit.messages.CometChatMessageList
 ### V6 Compose imports
 
 ```kotlin
-import com.cometchat.chatuikit.compose.conversations.CometChatConversations
-import com.cometchat.chatuikit.compose.messages.CometChatMessageList
+import com.cometchat.uikit.compose.presentation.conversations.ui.CometChatConversations
+import com.cometchat.uikit.compose.presentation.messagelist.ui.CometChatMessageList
 ```
 
 ### V6 Kotlin Views imports
 
 ```kotlin
-import com.cometchat.chatuikit.kotlin.conversations.CometChatConversations
-import com.cometchat.chatuikit.kotlin.messages.CometChatMessageList
+import com.cometchat.uikit.kotlin.presentation.conversations.ui.CometChatConversations
+import com.cometchat.uikit.kotlin.presentation.messagelist.ui.CometChatMessageList
 ```
 
-The skill rewrites imports during migration. Most projects can do a regex sweep:
+The skill rewrites imports during migration. The V6 namespace is `com.cometchat.uikit.{compose,kotlin}.presentation.<feature>.ui` — NOT the V5 `com.cometchat.chatuikit.*`. Most projects can do a regex sweep:
 
 ```bash
 # Compose path
-sed -i 's|com.cometchat.chatuikit.conversations|com.cometchat.chatuikit.compose.conversations|g' app/src/main/kotlin/**/*.kt
+sed -i -E 's|com.cometchat.chatuikit.([a-z]+)|com.cometchat.uikit.compose.presentation.\1.ui|g' app/src/main/kotlin/**/*.kt
 # Kotlin Views path
-sed -i 's|com.cometchat.chatuikit.conversations|com.cometchat.chatuikit.kotlin.conversations|g' app/src/main/kotlin/**/*.kt
+sed -i -E 's|com.cometchat.chatuikit.([a-z]+)|com.cometchat.uikit.kotlin.presentation.\1.ui|g' app/src/main/kotlin/**/*.kt
 ```
 
 But verify each rewrite — some V5 modules have been split or merged in V6 in ways the agent should review case-by-case.
@@ -326,14 +328,14 @@ For an in-progress migration, you can have V5 and V6 in the same module temporar
 
 □ Update gradle
   □ Remove chat-uikit-android:5.x
-  □ KEEP calls-sdk-android:5.0.+ (V6 needs it as peer dep — see §"Drop the calls-sdk-android dependency" above)
-  □ Add chatuikit-{compose,kotlin}-android:6.0.0-beta2
+  □ KEEP calls-sdk-android:5.0.+ (V6 needs it as peer dep — see §"KEEP calls-sdk-android:5.0.+" above)
+  □ Add chatuikit-{compose,kotlin}-android:6.0.+
   □ Add Compose deps (if applicable) or Material Components (if Kotlin Views)
 
 □ Rewrite init
-  □ UIKitSettingsBuilder → UIKitSettings.Builder()
-  □ Drop separate CometChatCalls.init; add .enableCalling() on UIKitSettings
-  □ CallbackListener → Result sealed class
+  □ UIKitSettingsBuilder → UIKitSettings.UIKitSettingsBuilder()
+  □ Drop separate CometChatCalls.init; add .setEnableCalling(true) on UIKitSettings
+  □ init callback stays CometChat.CallbackListener<String> (V6 did NOT switch to a Result/sealed-class API)
 
 □ Rewrite themes
   □ Activity theme parent → CometChatTheme.DayNight (Kotlin Views)
@@ -379,8 +381,8 @@ For an in-progress migration, you can have V5 and V6 in the same module temporar
 - [ ] `app/build.gradle.kts` has only one CometChat dep tree (V5 OR V6, not both)
 - [ ] `minSdk = 28` or higher
 - [ ] All V5 imports rewritten to the V6 surface (`compose` or `kotlin` namespace)
-- [ ] `UIKitSettingsBuilder` → `UIKitSettings.Builder()` everywhere
-- [ ] `.enableCalling()` on the builder if calls are used
+- [ ] `UIKitSettingsBuilder` → `UIKitSettings.UIKitSettingsBuilder()` everywhere
+- [ ] `.setEnableCalling(true)` on the builder if calls are used
 - [ ] Activity themes inherit `CometChatTheme.DayNight` (Kotlin Views path)
 - [ ] No `CometChatCalls.init` calls outside what V6 does internally
 - [ ] `calls-sdk-android:5.0.+` retained as explicit peer dep (V6 needs it; despite vendor marketing of "bundled calls")

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

@@ -3,13 +3,14 @@ name: cometchat-android-v6-production
 description: "CometChat Android UIKit v6 production readiness — token auth, ProGuard/R8, security checklist, release configuration"
 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: "shell, file-read, file-search, file-list"
 metadata:
   author: "CometChat"
   version: "3.0.0"
   tags: "cometchat, android, production, security, proguard, release, auth-token"
 ---
 
+> **Ground truth:** `com.cometchat:chatuikit-{compose,kotlin}-android:6.x` (+ `calls-sdk-android:5.x`) — resolved AAR (javap) + `ui-kit/android/v6`. **Official docs:** https://www.cometchat.com/docs/fundamentals/user-auth · **Docs MCP:** `claude mcp add --transport http cometchat-docs https://www.cometchat.com/docs/mcp` (or fetch the URL directly without MCP). Verify symbols against the installed package/source before relying on them.
+
 > **Companion skills:** cometchat-android-v6-core (init/login), cometchat-android-v6-builder-settings (UIKitSettings), cometchat-android-v6-push (FCM)
 
 ## Purpose
@@ -165,11 +166,13 @@ implementation("androidx.compose.material3:material3")
 Pin CometChat SDK versions explicitly:
 
 ```kotlin
-implementation("com.cometchat:chatuikit-compose-android:6.0.0-beta2")
+implementation("com.cometchat:chatuikit-compose-android:6.0.+")
 // or
-implementation("com.cometchat:chatuikit-kotlin-android:6.0.0-beta2")
+implementation("com.cometchat:chatuikit-kotlin-android:6.0.+")
 ```
 
+> Never pin `6.0.0-beta2` (or any `-beta` preview) in a production build — V6 went GA on 2026-05-25. The `6.0.+` dynamic pin tracks GA patches forward (ENG-35701). Pin an exact GA patch (e.g. `6.0.1`) if your release process requires reproducible builds.
+
 ## 6. minSdk 28 Implications
 
 v6 requires `minSdk = 28` (Android 9.0 Pie). This means: