@cometchat/skills 4.4.2 → 5.0.1

package/.claude-plugin/marketplace.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://code.claude.com/schemas/marketplace.json",
+  "name": "cometchat",
+  "description": "CometChat AI-coding skills (v5) — add real-time chat, voice/video calling and push to your app via your AI coding agent. Thin dispatcher + on-demand, verified UI Kit skills across React v7, Angular v5, React Native v5, Android v6 (Kotlin/Compose), iOS v5 (Swift/UIKit) and Flutter v6.",
+  "owner": {
+    "name": "CometChat",
+    "email": "support@cometchat.com"
+  },
+  "plugins": [
+    {
+      "name": "cometchat-skills",
+      "source": ".",
+      "skills": "./skills",
+      "strict": true,
+      "description": "UI Kit skills for integrating CometChat across React v7, Angular v5, React Native v5, Android v6 (Kotlin/Compose), iOS v5 (Swift/UIKit, SPM) and Flutter v6. The /cometchat dispatcher detects your project — web (React on Vite/Next/CRA, or Angular) or mobile (React Native/Expo, Android, iOS, Flutter) — and routes to task-shaped skills (core, components, placement, customization, features, calls, push, migration; plus platform patterns). Headless Calls SDK skills cover calling without a UI Kit. Run `/cometchat add chat to my app` to start. Thin entry with progressive disclosure. Backed by a deterministic CLI and a CI-gated verification pipeline: every skill is checked against its pinned kit (symbol catalog + compile fence), and several families also pass a live simulator/emulator smoke (per-family status in peers.yaml).",
+      "version": "5.0.1",
+      "author": {
+        "name": "CometChat"
+      },
+      "homepage": "https://github.com/cometchat/cometchat-skills",
+      "repository": "https://github.com/cometchat/cometchat-skills",
+      "license": "MIT",
+      "keywords": [
+        "chat",
+        "messaging",
+        "calls",
+        "react",
+        "vite",
+        "nextjs",
+        "ui-kit",
+        "cometchat",
+        "ai-agent",
+        "v7",
+        "ios",
+        "swift",
+        "uikit-ios",
+        "spm",
+        "xcode",
+        "v5",
+        "mobile",
+        "angular",
+        "react-native",
+        "android",
+        "android-sdk",
+        "flutter",
+        "js-calls",
+        "react-native-calls",
+        "android-calls",
+        "ios-calls",
+        "flutter-calls"
+      ],
+      "category": "communications"
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://code.claude.com/schemas/plugin.json",
+  "name": "cometchat-skills",
+  "version": "5.0.1",
+  "description": "CometChat AI-coding skills — add real-time chat, voice/video calling and push to your app via your AI coding agent, across React v7, Angular v5, React Native v5, Android v6 (Kotlin/Compose), iOS v5 (Swift/UIKit, SPM) and Flutter v6. Ships the first-party CometChat Docs MCP so skills read always-current docs automatically; falls back to a guided MCP add, then to a direct docs fetch.",
+  "author": {
+    "name": "CometChat",
+    "email": "support@cometchat.com"
+  },
+  "homepage": "https://github.com/cometchat/cometchat-skills",
+  "repository": "https://github.com/cometchat/cometchat-skills",
+  "license": "MIT",
+  "skills": "./skills"
+}

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# v5.0.1
+
+## New
+- **Migrate from another chat provider in one prompt.** Added **Sendbird → CometChat** and **Stream (GetStream) → CometChat** migration skills, installed for every platform. From a single "migrate my app to CometChat" prompt they inventory the app, replace each supported feature with its CometChat equivalent, remove the features CometChat has no equivalent for (and list them), rewire the token server and webhooks, and write a data-migration script for users, groups and message history — then run the import for you once the app migration is done and you provide credentials (dry-run first, then import).
+- The data-migration script works within CometChat's [Data Import](https://www.cometchat.com/docs/rest-api/data-import) limits (batch size and rate) and the ~6-month message-retention window (reach out to CometChat to import older history).
+
+---
+
+# v5.0.0
+
+## New
+- Added CometChat UI Kit integration skills for six platforms: React v7, Angular v5, React Native v5, iOS v5 (Swift / SPM), Android v6 (Kotlin / Compose), and Flutter v6.
+- Added headless Calls SDK v5 skills for JavaScript, React Native, iOS, Android, and Flutter, letting you add voice and video calling without a UI Kit.
+- Added a guided onboarding journey that scopes each integration — framework, features, placement, and theming — before any code is generated.
+- Added task-shaped skills per platform (core, components, placement, customization, features, calls, push, and migration) that load on demand as the build needs them.
+- Added automatic connection to the first-party CometChat Docs MCP, with a guided-add step and a direct documentation-fetch fallback, so skills always read current documentation.
+
+## Breaking
+- **Full pack replacement, not an additive update.** v5 is a new generation of skills — new platform targets (React v7, Angular v5, React Native v5, iOS v5, Android v6, Flutter v6), new skill names, and a new layout. Same package name (`@cometchat/skills`), so every existing v4 user is affected.
+- **82 v4 skill folders were removed** (the React-UI-Kit-v6 generation and its siblings — e.g. `cometchat-core`, `cometchat-features`, `cometchat-theming`). Their v5 equivalents live under the per-platform, task-shaped names above.
+- **Naming shift:** `cometchat-<platform>-v5-*` now refers to the Calls/Chat SDK skills on several platforms (e.g. `cometchat-flutter-v5-*` is the Calls SDK). Update any tooling that referenced v4 skill names.
+- **`@cometchat/skills-cli` is now credentials-only (v3.0.0).** The code-writing subcommands from v2 were removed; the CLI now fetches dashboard credentials (App ID, Region, Auth Key) and toggles extensions / AI features. v4-generated `AGENTS.md`/rules files that invoke removed commands should be regenerated.
+
+## Removed
+- 82 v4 skill folders (the React-UI-Kit-v6 generation and its siblings).
+- `packages/skills-native`, `packages/registry`, the deploy templates, and most of `docs/`.
+- The v2 code-writing CLI subcommands (see Breaking).
+
+## Upgrading from v4
+- **`@cometchat/skills add` removes stale v4 skills:** before laying down the current family's v5 skills it deletes the skill folders earlier versions shipped (e.g. `cometchat-core`, `cometchat-features`, `cometchat-theming`; the full list is in `bin/legacy-skills.json`) and prints what it removed, so no stale v4 skills are left behind. Other v5 skills already in the directory (a second family, a calls peer, a `--global` install from another project) and your own skills, including any you named `cometchat-*`, are untouched.
+- If you installed v4 skills into a location this CLI does not manage, or pinned old skill names in an `AGENTS.md` / editor-rules file, remove those references by hand.
+- The companion CLI changed majors (`@cometchat/skills-cli` 2.x → 3.x) and is credentials-only; run `npx @cometchat/skills-cli@3 --help` for the current commands.
+
+## Enhancements
+- The Claude Code plugin (`/plugin marketplace add cometchat/cometchat-skills`) now carries the v5 pack and auto-connects the CometChat Docs MCP.
+- `add` detects native projects too (an Xcode project or workspace, an iOS `Package.swift`, Gradle, `pubspec.yaml`), not just JavaScript frameworks. `--family` forces a platform or adds a headless Calls SDK skill alongside a UI Kit.
+- Agent instruction files (`AGENTS.md`, `GEMINI.md`, `CONVENTIONS.md`, `.windsurfrules`, `.clinerules/cometchat.md`, `.github/copilot-instructions.md`) are written inside a `<!-- cometchat-skills:start/end -->` block, so your own content in those files is kept.
+- `add --global` installs Claude Code skills to `~/.claude/skills` and prints the `claude mcp add --scope user` command instead of writing a project `.mcp.json`; agents with no user-level location are skipped with a note.
+- Smaller installs: each skill folder now gets only the reference files and catalogs its family's skills cite.
+- `@cometchat/skills-cli` warns when `.cometchat/config.json` (which can hold your Auth Key) is already tracked by git, and removed v2 commands explain where that functionality moved.
+- Skills are checked against the pinned UI Kit and SDK: a symbol catalog guards against hallucinated APIs and a compile fence confirms the generated code builds. Several families additionally pass a live smoke run on a real simulator/emulator; the remaining families are being wired to it (per-family status in `peers.yaml`).
+
+## Fixes
+- None

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CometChat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MIGRATING.md

@@ -0,0 +1,187 @@
+# Migrating from Sendbird or Stream (GetStream) to CometChat
+
+This guide takes an existing chat app built on **Sendbird** or **Stream Chat** and moves it to
+**CometChat** — in a single prompt to your AI coding agent. The agent does the whole job: it finds
+every place your app uses the old vendor, swaps each supported feature for its CometChat equivalent,
+removes the few features CometChat has no equivalent for, rewrites your token server and webhooks,
+writes a script to import your users and message history, uninstalls the vendor, and checks the build.
+
+It works whether your app uses the vendor's **UI Kit** (their prebuilt chat components) or their
+**SDK / low-level client** (your own UI on their client) — or a mix of both. Every CometChat API it
+writes is fetched from the live CometChat docs, never guessed.
+
+Supported app platforms: **React, Angular, React Native / Expo, iOS, Android, Flutter.**
+
+---
+
+## Before you start (prerequisites)
+
+1. **A CometChat account and app.** Sign up free at [app.cometchat.com](https://app.cometchat.com)
+   and create an app. From **Dashboard → your app**, note the **App ID**, **Region**, and **Auth Key**
+   (under *Credentials*). For importing history you'll also create a **REST API key** (full access) —
+   see step 6.
+   - Create your CometChat app yourself. The migration never creates one for you.
+2. **Node.js 18 or newer** (for `npx` and the data-import script).
+3. **Your app builds today**, on the vendor, with your normal build command. Migrating an app that
+   doesn't build first only hides which errors were yours.
+4. **A clean git working tree.** The agent works on a new `cometchat-migration` branch and never
+   commits — but start from a clean state so the diff is easy to review.
+5. **Your AI coding agent** with the CometChat skills installed (next step). Claude Code is the
+   default; Cursor, Copilot, Windsurf, Cline, Continue, Gemini, Kiro, Replit and others are supported.
+
+---
+
+## Step 1 — Install the CometChat skills into your project
+
+From your project root:
+
+```bash
+npx @cometchat/skills add
+```
+
+That installs the skills for Claude Code and connects the CometChat Docs MCP. For another agent, pass
+`--ide` (for example `--ide cursor`); run `npx @cometchat/skills add --help` for the full list. Commit
+the installed skill files if you want your whole team to share them.
+
+> The skills that do the migration — `cometchat-migrate-from-sendbird` and
+> `cometchat-migrate-from-getstream` — are installed for every platform, so you don't pick one; the
+> agent selects the right one from what your project uses.
+
+## Step 2 — (Optional) fetch your credentials without copy-paste
+
+You can paste your App ID / Region / Auth Key by hand later, or let the credentials CLI fetch them:
+
+```bash
+npx @cometchat/skills-cli@3 auth login       # opens the dashboard in your browser
+npx @cometchat/skills-cli@3 provision run     # writes .cometchat/config.json (git-ignored, owner-only)
+```
+
+The migration reuses `.cometchat/config.json` if it's there, so this saves a step. Skip it if you'd
+rather paste.
+
+## Step 3 — Ask your agent to migrate
+
+Open your project in your agent and say:
+
+```
+migrate my app to CometChat
+```
+
+That's the whole instruction. You don't name the vendor — the agent detects Sendbird or Stream from
+your dependencies. It then runs end-to-end **without stopping to ask you questions**, taking sensible
+defaults and recording each one in the report at the end.
+
+You can also be explicit: *"migrate my app from Sendbird to CometChat"* /
+*"replace Stream Chat with CometChat"*.
+
+### What the agent does, in order
+
+1. **Detects** your framework and which vendor you're on, and creates a `cometchat-migration` git branch.
+2. **Inventories** every use of the vendor: UI Kit screens, SDK/client calls, event handlers, calls,
+   push, the token server, webhooks, env vars and tests.
+3. **Maps each feature** to CometChat, checking the CometChat docs at both levels — the **UI Kit** and
+   the **Chat SDK / REST API**. A feature with a UI Kit component is wired with that component; a
+   feature with only an SDK method is built on that method in your own UI. Every API is taken from the
+   live docs.
+4. **Installs CometChat** and wires init → login → render, keeping your own screens and routes.
+5. **Replaces usage file by file** — UI Kit components for UI-Kit apps, CometChat SDK calls for
+   client-mode apps, or both for a mixed app.
+6. **Removes, in full,** any feature CometChat genuinely doesn't offer (code, buttons, routes,
+   dependencies) — no dead ends left behind.
+7. **Rewrites the server side** — your token endpoint mints CometChat auth tokens; your webhooks map
+   to CometChat webhooks.
+8. **Writes a data-migration script** (`scripts/cometchat-migration/`) for your users, groups and
+   history, then — once the app migration is done — asks for your credentials and **runs the import
+   for you** (dry-run first, then import). If you don't share credentials, it's left for you to run.
+9. **Uninstalls the vendor** and re-runs your package manager.
+10. **Verifies the build** and writes `COMETCHAT_MIGRATION.md`.
+
+## Step 4 — Read the report
+
+At the repo root you'll find **`COMETCHAT_MIGRATION.md`**, and the agent ends its reply with its two
+key lists:
+
+- **Removed — not available in CometChat.** Each row names the feature, the files it touched, what
+  users lose, and the closest CometChat alternative. Review these — this is where you decide whether to
+  rebuild anything a different way or drop it.
+- **Your action items.** The remaining manual steps (below), in order.
+
+## Step 5 — Add your credentials and run it
+
+If you didn't do step 2, put your credentials in the env file the report names (for React that's an
+untracked `.env.local` with `VITE_COMETCHAT_APP_ID` / `VITE_COMETCHAT_REGION` /
+`VITE_COMETCHAT_AUTH_KEY`), then start the app:
+
+```bash
+npm run dev
+```
+
+Sign in as one of **your own** users — the UID your server's `toCometChatId()` produces for them,
+created in Dashboard → **Users** or by the import in Step 6. (A fresh app also seeds sample users such
+as `cometchat-uid-1`; they're fine for a quick smoke test, but never hardcode one — production login is
+your server-minted auth token.) You should see your conversations and be able to send a message.
+
+## Step 6 — Import your existing users and history
+
+Once the app migration is done, the agent asks for your credentials and runs `scripts/cometchat-migration/` for you (dry-run first, then import). If you didn't share credentials at the time, run it yourself:
+
+1. In the CometChat Dashboard, create a **REST API key** with full access.
+2. Read `scripts/cometchat-migration/README.md`, set the environment variables it lists (your vendor
+   export credentials + your CometChat App ID / Region / REST API key).
+3. **Dry-run first**, then import:
+   ```bash
+   node scripts/cometchat-migration/migrate.mjs --dry-run
+   node scripts/cometchat-migration/migrate.mjs
+   ```
+4. Spot-check a few conversations in the app, then delete the export files (they hold user data).
+
+The import uses CometChat's [Data Import API](https://www.cometchat.com/docs/rest-api/data-import) and
+respects its limits (50 records per request, 60 requests per minute). Re-running it is safe.
+
+**Choose a cut-over strategy:**
+- **Hard switch (default here)** — export from the old vendor, import into CometChat, deploy. Simplest; do it in a maintenance window so no messages are sent mid-copy. The generated script does this.
+- **Zero-downtime live migration** — keep both systems in sync while users roll onto the new build gradually. This bridges the two providers and is set up with CometChat's team: [contact sales](https://www.cometchat.com/contact-sales). Pick this if you can't take a window.
+See [Data Import and Migration](https://www.cometchat.com/docs/fundamentals/data-import-and-migration) for both.
+
+## Step 7 — Go to production
+
+- Enable in the CometChat Dashboard any features the report lists (extensions, AI, Search, etc.).
+- For push, upload your FCM / APNs credentials to CometChat.
+- Point your webhooks at the new receiver and pick the events.
+- **Switch login from the dev Auth Key to server-minted auth tokens.** The Auth Key is for development
+  only; in production your server mints a per-user token
+  ([auth tokens](https://www.cometchat.com/docs/rest-api/auth-tokens)) and the client logs in with
+  `loginWithAuthToken()`. The agent leaves this as an action item and, where your app already had a
+  token server, wires it for you.
+- Remove the old vendor's secrets from your CI and hosting, and deactivate the vendor app after the
+  cut-over.
+
+---
+
+## What migrates, and what doesn't
+
+**Migrated** (fetched from the CometChat docs): 1:1 and group chat, conversation list, send / edit /
+delete, typing indicators, read/delivery receipts, attachments, threads, reactions, mentions, polls,
+message search, translation, link previews, presence, group membership and moderation, calls, and push
+— wherever CometChat offers them for your platform.
+
+**Removed** (no CometChat equivalent, examples): scheduled messages, atomic channel counters, custom
+slash commands, arbitrary location sharing, Stream Activity Feeds, and vendor-only dev/QA tooling.
+Every removal is listed in the report with its files and the closest alternative.
+
+**Changed** (works differently): open/livestream channels become public groups; very large groups
+(over 300 members) don't send receipts or typing indicators; a fresh group appears in the list after
+its first message.
+
+---
+
+## Notes
+
+- **One CometChat app for dev, one for production** is the recommended setup; migrate against dev
+  first.
+- **Identity is preserved.** Your existing user IDs are converted to valid CometChat UIDs by one shared
+  rule used by the client, the server and the import script, so logins and imported history line up.
+- **Nothing is destroyed.** The agent works on a branch and never force-deletes non-vendor code; your
+  vendor code is what it removes, by design.
+- If no Sendbird or Stream usage is found, the agent says so and points you at
+  `npx @cometchat/skills add` for a fresh integration instead.

package/README.md

@@ -1,199 +1,95 @@
-# cometchat-skills
+# @cometchat/skills (v5)
 
-**Add CometChat to any React, React Native, Angular, Android, Flutter, or iOS project through your AI coding agent.** Works with Claude Code, Cursor, Codex, VS Code Copilot, Windsurf, Cline, Kiro, and [50+ more agents](https://github.com/vercel-labs/skills).
+**Add CometChat chat & calling to your app through your AI coding agent.** Install the skills, then ask your agent *"add chat to my app"* — it has a short conversation with you (framework, intent, placement, credentials), then writes production-grade integration code into the files you already have.
 
-v4 takes an AI-first approach: your agent has a short conversation with you to understand your project and chat requirements, then writes production-grade integration code tailored to the files you already have. One slash — `/cometchat` — works for every supported framework, on web, mobile, and native.
+v5 is a **multi-platform** pack: a thin `cometchat` dispatcher + an `onboarding` journey + on-demand, verified skills for six UI Kits — **React v7 · Angular v5 · React Native v5 · iOS v5 · Android v6 · Flutter v6** — plus headless **Calls SDK v5** skills (JavaScript · React Native · iOS · Android · Flutter) and the **Android Chat SDK v5**. It's **docs-maximal** (builds from the official CometChat task guides and verifies against them) and **two-gate tested** (a deterministic reviewer + a black-box acceptance explorer).
 
-## Install
-
-```bash
-npx @cometchat/skills add
-```
+> **v5 ships on npm as `@cometchat/skills` (5.x).** It's a multi-platform rewrite of the v4 pack — same package name, new major. Upgrading? `add` removes the old v4 skills for you (see `CHANGELOG.md`).
 
-That's it — one command for every supported framework. The installer detects what you're working with (React, Next.js, React Router, Astro, Expo, bare React Native, Angular, native Android, Flutter, or native iOS) from your project, then opens an interactive picker so you can choose which AI agents to install for — Claude Code, Cursor, Codex, Cline, Kiro, Replit Agent, and [50+ more](https://github.com/vercel-labs/skills) all in one pass.
-
-Override detection if needed:
-
-```bash
-npx @cometchat/skills add --family web      # React / Next.js / React Router / Astro
-npx @cometchat/skills add --family native   # Expo / bare RN
-npx @cometchat/skills add --family angular  # Angular 17-21
-npx @cometchat/skills add --family android  # Native Android (V6 stable, recommended + V5 legacy)
-npx @cometchat/skills add --family flutter  # Flutter (V6 stable, recommended + V5 legacy)
-npx @cometchat/skills add --family ios      # Native iOS (V5 stable)
-npx @cometchat/skills add --family all      # install every published skill
-```
-
-### Two install shapes
-
-**Base install (default, recommended)** — `npx @cometchat/skills add` writes only the cross-family skills (the `cometchat` dispatcher and friends). Smallest initial install. After it lands, open your project in your IDE and run `/cometchat`:
-
-1. The dispatcher detects your framework (Vite + React → `web`, Expo → `native`, etc.)
-2. It asks the agent to install family-specific skills on demand via `npx @cometchat/skills add --family <X> --ide <Y>`
-3. The agent gets the 13 web skills (or 31 android, 28 flutter, etc.) at exactly the moment they're needed
-4. Integration continues with the full skill set loaded
-
-You install once with the multi-agent picker (Claude Code, Cursor, Codex, Cline, Kiro, Replit Agent, [50+ more](https://github.com/vercel-labs/skills)); the dispatcher handles framework-specific expansion as the project actually needs it.
-
-**Full family install** — `npx @cometchat/skills add --family <name>` writes the dispatcher + every skill for that family upfront (web=13, android=31, flutter=28, etc.). Use when you know the framework upfront and want all skills present without runtime expansion. Power users + CI smoke tests.
+## Install
 
 ```bash
-# Base install (recommended) — picker + dispatcher routes the rest
 npx @cometchat/skills add
-
-# Full family install — power-user / CI flow
-npx @cometchat/skills add --family web      # all 13 web skills upfront
-npx @cometchat/skills add --family native   # all 13 RN skills upfront
-npx @cometchat/skills add --family android  # all 31 Android skills upfront
-# ... etc
 ```
 
-### Direct-write to one IDE (CI / Dockerfile)
-
-When stdin isn't a TTY (CI, Docker), or when you pass `--ide <name>`, the picker is skipped and skills are written directly to one IDE's directory. Default is base install; pass `--family <name>` for the full family install.
+The installer **detects your project automatically** — React (Vite, Next.js, CRA, Astro, React Router), Angular, React Native / Expo, and native iOS (Xcode project), Android (Gradle) and Flutter (`pubspec.yaml`) — and installs the skills for your coding agent: **Claude Code by default**; target another with `--ide` (Cursor, Codex, Cline, Kiro, Replit Agent, Windsurf, Copilot, Gemini, …) or `--ide all`. Use `--family` to force a platform (e.g. from a monorepo root) or to add the headless SDK skills **alongside** a UI Kit — a second `add` never removes the first family's skills:
 
 ```bash
-npx @cometchat/skills add --ide claude              # base install to .claude/skills/
-npx @cometchat/skills add --ide cursor              # base install to .cursor/skills/
-npx @cometchat/skills add --ide kiro                # base install to .kiro/skills/
-npx @cometchat/skills add --ide replit              # base install to .agents/skills/
-npx @cometchat/skills add --ide copilot             # base install to .github/copilot-instructions.md
-npx @cometchat/skills add --ide all                 # write base install to every supported IDE
-npx @cometchat/skills add --ide claude --family web # full web family install to .claude/skills/
+npx @cometchat/skills add --family flutter      # force the Flutter v6 UI Kit skills
+npx @cometchat/skills add --family js-calls     # add headless JS Calls SDK skills next to the React ones
 ```
 
-Direct-write supports 10 agents: `claude`, `cursor`, `kiro`, `replit`, `copilot`, `continue`, `cline`, `aider`, `codex`, `gemini`. The interactive picker supports 55+ via the vercel-labs/skills ecosystem.
+Pin the agent as well (CI / Docker) with `--ide claude|cursor|codex|replit|…` (e.g. `--ide claude` → `.claude/skills/`). The full `--family` list is: `react · angular · react-native · ios · android · flutter` (UI Kits) and `android-sdk · react-native-calls · ios-calls · android-calls · flutter-calls · js-calls` (headless SDKs).
 
-Pass `--no-picker` to force direct-write even in an interactive terminal.
+## Use it
 
-> **Migrating from v3?** `npx @cometchat/skills-native add` still works (with a deprecation notice). New projects should use the unified command.
-
-Then in your IDE:
+After install, open your project in your agent and say:
 
 ```
-/cometchat add chat to my app
+add chat to my app
 ```
 
-Or add voice & video calling (new in v4.2):
+The `cometchat` dispatcher routes to `cometchat-onboarding` (discover → understand → plan → approve), then hands a scoped build directive to that platform's `-core` skill, pulling in the others as the approved plan needs them (components, placement, theming, features, calls, push). Iterate afterward — *"add reactions" · "switch to dark mode" · "add a details side panel" · "switch to server-minted auth tokens"* (production auth — server-minted `loginWithAuthToken` — is covered inside each family's `-core` credentials/lifecycle guidance, and by the dedicated `-production` skill where one exists).
 
-```
-/cometchat add voice and video calls to my app
-```
-
-When integrating chat, the dispatcher now asks **how** you want to customize (new in v4.3):
+### Migrating from Sendbird or Stream (GetStream)
 
 ```
-◉ Visually — enable-disable in browser
-○ In code — code-driven defaults
+migrate my app to CometChat
 ```
 
-Pick **Visually** and the dispatcher opens CometChat's Visual Builder in your browser, waits while you customize colors / layout / features, then fetches the config and emits the integration into your existing app — no ZIP downloads, no manual file copying. Works for React, React Native, iOS, Android v6, and Flutter v6. Angular customers auto-route to the In-code path (Visual Builder doesn't ship Angular code yet).
-
-## What happens
-
-1. **Detects** your framework (React / Next.js / React Router / Astro / Expo / bare React Native / Angular / Android / Flutter / iOS), router, env prefix, existing auth system
-2. **Onboards** you to CometChat in the terminal — no browser round-trip. Signup, login, app creation all via the CLI.
-3. **Asks** what you're building (marketplace, SaaS, messaging, support, social, or just exploring) and **where** chat should live in your project — it reads your routes/screens, nav, and components before proposing a placement that fits (route+drawer for web, stack/tab/modal/bottom-sheet for RN, route/modal for Angular, Activity/Fragment for Android, navigation controller for iOS, route/modal sheet for Flutter)
-4. **Shows the plan** — exactly which files it will create, which it will modify, and which it will not touch — and waits for your approval
-5. **Writes** the provider, integration components, and route/screen/trigger wiring
-6. **Saves** credentials with the correct convention for your framework (`.env` with `VITE_` / `NEXT_PUBLIC_` / `PUBLIC_` / `EXPO_PUBLIC_` prefix on web/RN; `src/environments/environment.ts` on Angular; `local.properties` + `BuildConfig` on Android; `Secrets.swift` / `.xcconfig` on iOS; Dart const file or `--dart-define` on Flutter) and records your choices in `.cometchat/config.json`
-
-No templates, no experiences to pick — the agent writes real code that fits your app.
-
-## Supported frameworks
-
-| Framework | Chat | Voice & Video Calls | Visual Builder |
-|---|---|---|---|
-| React.js / Vite / CRA | ✅ | ✅ Ringing + Session | ✅ (v4.3) |
-| Next.js (App Router + Pages Router) | ✅ | ✅ Ringing + Session | ✅ (v4.3) |
-| React Router v6 / v7 | ✅ | ✅ Ringing + Session | ✅ (v4.3) |
-| Astro (React islands) | ✅ | ✅ Ringing + Session | ✅ (v4.3) |
-| Expo (managed + Expo Router) | ✅ | ✅ Ringing + Session | ✅ (v4.3) |
-| Bare React Native (CLI) | ✅ | ✅ Ringing + Session | ✅ (v4.3) |
-| Angular 17-21 | ✅ | ✅ Ringing + Session | ❌ (auto-falls back to In code) |
-| Android (V6 stable, recommended + V5 legacy) | ✅ | ✅ Ringing + Session | ✅ V6 (v4.3) |
-| Flutter (V6 stable, recommended + V5 legacy) | ✅ | ✅ Ringing + Session | ✅ V6 chat-only (v4.3) |
-| iOS (V5 stable) | ✅ | ✅ Ringing + Session | ✅ (v4.4) |
+In a project that uses Sendbird or Stream Chat, this one prompt runs the whole migration, with no plan/approve round-trip. `detect` spots the vendor (`migrate_from`), and `cometchat-migrate-from-sendbird` / `cometchat-migrate-from-getstream` then:
+- works on a `cometchat-migration` git branch;
+- replaces every supported feature with its CometChat equivalent on your platform's UI Kit or SDK;
+- **fully removes** the features CometChat doesn't have (code, UI entry points, dependencies);
+- rewires your server's token endpoint and webhooks;
+- writes a data-migration script for users, groups and message history and runs it for you once you provide the credentials (after the app migration is done);
+- uninstalls the vendor and checks that the build passes.
 
-**Calling modes:**
-- **Ringing** — kit-driven incoming/outgoing call surfaces, system-level VoIP push (CallKit on iOS, ConnectionService on Android, web push fallback on browsers). Production-grade for 1:1 + group calls.
-- **Session** — both peers join a shared `/meet/:sessionId` URL. No ringing. For embedded meetings, scheduled calls, support flows, broadcast use-cases.
+It ends with `COMETCHAT_MIGRATION.md` and prints two lists: what was removed, and what you still need to do (credentials, dashboard toggles, running the import).
 
-The dispatcher asks Ringing vs Session up front in Step 3.0.
+**Full step-by-step guide (prerequisites, install, run, data import, go-live):** [MIGRATING.md](MIGRATING.md).
 
-## After the first integration
+## Credentials (dashboard CLI)
 
-Re-run `/cometchat` anytime to pick from the iteration menu:
+A separate, dashboard-only CLI fetches your App ID / Region / Auth Key so you don't paste them by hand:
 
-- **Customize look & feel** — theme presets (slack / whatsapp / imessage / discord / notion) or your own brand color
-- **Add a feature** — 40+ features including calls, reactions, polls, AI smart replies, file sharing, presence
-- **Customize a component** — custom message bubbles, headers, composer actions, empty/loading states
-- **Add another placement** — floating widget (web), modal / bottom sheet / extra tab (RN)
-- **Set up production auth** — replace the dev Auth Key with a server-side token endpoint
-- **Set up user management** — server endpoints for creating/updating/deleting CometChat users
-- **Run diagnostics** — verify, drift detection, symptom-to-cause lookup
-
-React Native projects also get **Set up push notifications** (APNs + FCM end-to-end), **Set up testing** (Jest + RNTL + Detox/Maestro), and **Troubleshoot an issue** (Metro cache, pod install, privacy manifest) in the menu.
-
-## Recommended: CometChat Docs MCP
-
-For deeper component customization (custom views, SDK events, request builders), install the docs MCP:
-
-**Claude Code:**
 ```bash
-claude mcp add --transport http cometchat-docs https://www.cometchat.com/docs/mcp
+npx @cometchat/skills-cli@3 auth login
+npx @cometchat/skills-cli@3 provision run
 ```
 
-**Cursor** (`.cursor/mcp.json`):
-```json
-{ "mcpServers": { "cometchat-docs": { "url": "https://www.cometchat.com/docs/mcp" } } }
-```
+The CLI is dashboard/API-only (`auth · provision · config · features`) — it never writes framework code; the skills do all detection, env-writing, and codegen.
 
-**Windsurf:**
-```json
-{ "mcpServers": { "cometchat-docs": { "type": "sse", "serverUrl": "https://www.cometchat.com/docs/mcp" } } }
-```
+## What's in the pack
 
-No authentication required. Not needed for the initial integration — the skill handles Phase A without it.
+A thin `cometchat` router + a `cometchat-onboarding` journey + two competitor-migration skills (`cometchat-migrate-from-sendbird`, `cometchat-migrate-from-getstream`, installed for every platform), then a **full skill set per platform**. Every UI-Kit family ships `core` (install · credentials · init→login→render · the golden-path chat surface) plus, as the platform needs them, `components · placement · customization · features · calls · push · migration` and platform extras (`patterns`, `production`, `testing`, `troubleshooting`, `events`, the Android `compose-*` / `kotlin-*` cohorts):
 
-## CLI (used by the agent under the hood)
+| Family | UI Kit package | Consumption |
+|---|---|---|
+| **React v7** | `@cometchat/chat-uikit-react@7` | drop-in UI Kit (+ Vite / Next.js / React Router / Astro glue) |
+| **Angular v5** | `@cometchat/chat-uikit-angular@5` | drop-in UI Kit |
+| **React Native v5** | `@cometchat/chat-uikit-react-native@5` | drop-in UI Kit (bare + Expo) |
+| **iOS v5** | `CometChatUIKitSwift` (SPM) | drop-in UI Kit (host-composed screens) |
+| **Android v6** | `chatuikit-{compose,kotlin}-android` | drop-in UI Kit (Compose + Kotlin/View) |
+| **Flutter v6** | `cometchat_chat_uikit ^6` | drop-in UI Kit |
+| **Calls SDK v5** (headless) | JS · React Native · iOS · Android · Flutter | standalone voice/video, no UI Kit |
+| **Chat SDK v5** (headless) | Android | headless messaging, no UI Kit |
 
-The skill calls `@cometchat/skills-cli` commands. You can also run them directly:
+## Compatibility
 
-```bash
-# Onboarding
-npx @cometchat/skills-cli auth signup       # create account, all in terminal
-npx @cometchat/skills-cli auth login        # sign in (masked password)
-npx @cometchat/skills-cli auth status       # check current session
-
-# App provisioning — web example
-npx @cometchat/skills-cli provision list    # list apps on your account
-npx @cometchat/skills-cli provision setup \
-  --name my-chat --region us --industry saas_businesses \
-  --framework reactjs                       # create app + write .env (VITE_ prefix) + save config
-
-# App provisioning — React Native example (Expo or bare RN)
-npx @cometchat/skills-cli provision setup \
-  --name my-rn-chat --region us --industry online_marketplaces \
-  --framework expo                          # writes EXPO_PUBLIC_* env vars
-# Use --framework react-native for bare RN (no env prefix; pair with react-native-dotenv)
-
-# Project introspection
-npx @cometchat/skills-cli detect            # framework, router, env prefix
-npx @cometchat/skills-cli config show       # read .cometchat/config.json
-npx @cometchat/skills-cli doctor            # diagnostics
-
-# See everything
-npx @cometchat/skills-cli --help
-```
+- **React v7** — `@cometchat/chat-uikit-react@7` (7.1.x) + `@cometchat/chat-sdk-javascript@4`; calls `@cometchat/calls-sdk-javascript@5`. React ≥ 18.
+- **Angular v5** — `@cometchat/chat-uikit-angular@5` (5.1–5.2) + Chat SDK v4 + Calls SDK v5. Angular 17–21.
+- **React Native v5** — `@cometchat/chat-uikit-react-native@5` + `@cometchat/chat-sdk-react-native@4` + `@cometchat/calls-sdk-react-native@5`.
+- **iOS v5** — `CometChatUIKitSwift` 5.1.x + `CometChatSDK` 4.1.x + `CometChatCallsSDK` 5.0.x (Swift Package Manager).
+- **Android v6** — `chatuikit-{compose,kotlin}-android` 6.0.x + `chat-sdk-android` 5.0.x + `calls-sdk-android` 5.0.x.
+- **Flutter v6** — `cometchat_chat_uikit ^6` (6.1.x) + `cometchat_calls_sdk ^5` (calls).
 
-## Prerequisites
+Exact pinned versions per family live in `peers.yaml` and each family's `SKILL.md` frontmatter (both ship in the package).
 
-- An AI coding agent ([Claude Code](https://claude.ai/code), [Cursor](https://cursor.sh), [Kiro](https://kiro.dev), VS Code Copilot, or any [skills.sh](https://skills.sh)-compatible agent)
-- Node.js 18+
-- React 18+ (React 19 fully supported)
+## Links
 
-No CometChat account required before starting — the skill walks you through signup from the terminal.
+- Docs: [cometchat.com/docs](https://www.cometchat.com/docs)
+- UI Kits: [`@cometchat/chat-uikit-react`](https://www.npmjs.com/package/@cometchat/chat-uikit-react) · [`-angular`](https://www.npmjs.com/package/@cometchat/chat-uikit-angular) · [`-react-native`](https://www.npmjs.com/package/@cometchat/chat-uikit-react-native)
 
 ## License