@amityco/social-plus-vise 1.6.0 → 1.8.0

package/dist/tools/project.js

@@ -39,7 +39,7 @@ export async function inspectProject(repoPath, surfacePath) {
     const surfaces = await detectProjectSurfaces(repoRoot);
     const effectiveRoot = resolveSurfaceRoot(repoRoot, surfacePath);
     const selectedSurface = surfacePath ? await surfaceForPath(repoRoot, effectiveRoot) : surfaceMatchingRoot(surfaces, repoRoot);
-    const { platforms, signals, designSignals } = await inspectRoot(effectiveRoot);
+    const { platforms, signals, designSignals, scanCoverage } = await inspectRoot(effectiveRoot);
     return {
         repoRoot,
         effectiveRoot,
@@ -48,6 +48,7 @@ export async function inspectProject(repoPath, surfacePath) {
         signals,
         designSignals,
         surfaces,
+        scanCoverage,
     };
 }
 function resolveSurfaceRoot(repoRoot, surfacePath) {
@@ -63,6 +64,7 @@ function resolveSurfaceRoot(repoRoot, surfacePath) {
 }
 async function inspectRoot(root) {
     const signals = [];
+    const scanContext = { validationRoot: root, scans: [] };
     const candidates = [
         ["android", "settings.gradle", "Gradle project settings"],
         ["android", "settings.gradle.kts", "Gradle Kotlin project settings"],
@@ -100,7 +102,7 @@ async function inspectRoot(root) {
     }
     const hasJsSignal = signals.some((signal) => signal.platform === "typescript" || signal.platform === "react-native");
     if (!hasJsSignal) {
-        const sourceSignal = await detectSdkSignalFromSource(root);
+        const sourceSignal = await detectSdkSignalFromSource(root, scanContext);
         if (sourceSignal) {
             signals.push(sourceSignal);
         }
@@ -113,10 +115,18 @@ async function inspectRoot(root) {
         : hasAndroid
             ? rawPlatforms.filter((p) => p !== "typescript")
             : rawPlatforms;
-    return { platforms, signals, designSignals: await detectDesignSignals(root) };
+    return {
+        platforms,
+        signals,
+        designSignals: await detectDesignSignals(root),
+        scanCoverage: {
+            complete: scanContext.scans.every((scan) => !scan.truncated),
+            scans: scanContext.scans,
+        },
+    };
 }
-async function detectSdkSignalFromSource(root) {
-    const sourceFiles = await findFiles(root, [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".html", ".htm"], 500);
+async function detectSdkSignalFromSource(root, scanContext) {
+    const sourceFiles = await findFiles(root, [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".html", ".htm"], 500, scanContext, "platform-detection.javascript-source");
     if (sourceFiles.length === 0) {
         return null;
     }
@@ -269,7 +279,25 @@ async function installedBlockEntryStillValid(root, entry) {
             return false;
         }
     }
-    return true;
+    const publicEntrypoint = typeof entry.publicEntrypoint === "string" ? entry.publicEntrypoint : "";
+    const importName = typeof entry.importName === "string" ? entry.importName : "";
+    const mountFiles = Array.isArray(entry.mountFiles) ? entry.mountFiles : [];
+    if (!publicEntrypoint || !importName || mountFiles.length === 0) {
+        return false;
+    }
+    const usagePattern = platform === "flutter"
+        ? new RegExp(`\\b${escapeRegExp(importName)}\\s*\\(`)
+        : new RegExp(`<\\s*${escapeRegExp(importName)}(?:\\s|/|>)|(?:React\\.)?createElement\\s*\\(\\s*${escapeRegExp(importName)}\\b|\\b${escapeRegExp(importName)}\\s*\\(`);
+    for (const mountFile of mountFiles) {
+        if (typeof mountFile !== "string" || mountFile.trim() === "") {
+            continue;
+        }
+        const source = await readIfExists(path.join(root, mountFile));
+        if (source.includes(publicEntrypoint) && usagePattern.test(source)) {
+            return true;
+        }
+    }
+    return false;
 }
 async function sidecarOutcomeInScope(root, outcome) {
     const dir = sidecarDir(root);
@@ -354,29 +382,56 @@ export const validateSetupTool = {
         const repoPath = stringField(args, "repoPath");
         const inspection = await inspectProject(repoPath, optionalStringField(args, "surfacePath"));
         const platform = optionalStringField(args, "platform") ?? inspection.platforms[0] ?? "unknown";
-        const findings = await validateSetup(inspection.effectiveRoot, platform);
+        const validation = await validateSetupWithCoverage(inspection.effectiveRoot, platform);
+        const platformWasExplicit = optionalStringField(args, "platform") !== undefined;
+        const scanCoverage = platformWasExplicit
+            ? validation.scanCoverage
+            : {
+                complete: inspection.scanCoverage.complete && validation.scanCoverage.complete,
+                scans: [...inspection.scanCoverage.scans, ...validation.scanCoverage.scans],
+            };
+        const findings = [...validation.findings];
+        if (!platformWasExplicit && !inspection.scanCoverage.complete && !findings.some((finding) => finding.ruleId === "project.scan.complete")) {
+            findings.push(incompleteInspectionFinding(inspection.scanCoverage));
+        }
         return textResult({
             platform,
             surfacePath: inspection.selectedSurface?.path,
             status: statusForFindings(findings),
             findings,
+            scanCoverage,
         });
     },
 };
 export async function validateSetup(repoPath, platform) {
+    return (await validateSetupWithCoverage(repoPath, platform)).findings;
+}
+function incompleteInspectionFinding(scanCoverage) {
+    const truncated = scanCoverage.scans.filter((scan) => scan.truncated);
+    return {
+        ruleId: "project.scan.complete",
+        severity: "error",
+        message: `Vise could not inspect the complete project inventory: ${truncated
+            .map((scan) => `${scan.scope} reached its ${scan.limit}-file limit under ${scan.root}`)
+            .join("; ")}.`,
+        recommendation: "Point Vise at the specific app with --surface/--surface-path before planning, initializing, validating, or selecting sensors.",
+    };
+}
+export async function validateSetupWithCoverage(repoPath, platform) {
     const root = path.resolve(repoPath);
     const findings = [];
+    const scanContext = { validationRoot: root, scans: [] };
     if (platform === "android") {
-        findings.push(...(await validateAndroid(root)));
+        findings.push(...(await validateAndroid(root, scanContext)));
     }
     if (platform === "flutter") {
-        findings.push(...(await validateFlutter(root)));
+        findings.push(...(await validateFlutter(root, scanContext)));
     }
     if (platform === "typescript" || platform === "react-native") {
-        findings.push(...(await validateTypeScript(root, platform)));
+        findings.push(...(await validateTypeScript(root, platform, scanContext)));
     }
     if (platform === "ios") {
-        findings.push(...(await validateIos(root)));
+        findings.push(...(await validateIos(root, scanContext)));
     }
     if (platform === "unknown") {
         findings.push({
@@ -386,21 +441,38 @@ export async function validateSetup(repoPath, platform) {
             recommendation: "Point repoPath at the app root or provide a platform override.",
         });
     }
-    return findings;
+    const truncatedScans = scanContext.scans.filter((scan) => scan.truncated);
+    if (truncatedScans.length > 0) {
+        findings.push({
+            ruleId: "project.scan.complete",
+            severity: "error",
+            message: `Vise could not inspect the complete source surface: ${truncatedScans
+                .map((scan) => `${scan.scope} reached its ${scan.limit}-file limit under ${scan.root}`)
+                .join("; ")}.`,
+            recommendation: "Point Vise at the specific app with --surface/--surface-path, remove generated or vendored source from that surface, or raise the governed scan limit before relying on absence-based validation.",
+        });
+    }
+    return {
+        findings,
+        scanCoverage: {
+            complete: truncatedScans.length === 0,
+            scans: scanContext.scans,
+        },
+    };
 }
-async function validateAndroid(root) {
+async function validateAndroid(root, scanContext) {
     const findings = [];
     const manifestPath = "app/src/main/AndroidManifest.xml";
     const manifest = await readIfExists(path.join(root, manifestPath));
-    const gradleScripts = (await findFiles(root, [".gradle", ".kts"], 200)).filter((f) => /(?:^|[\\/])(?:build|settings)\.gradle(?:\.kts)?$/.test(f));
+    const gradleScripts = (await findFiles(root, [".gradle", ".kts"], 200, scanContext, "android.gradle-manifests")).filter((f) => /(?:^|[\\/])(?:build|settings)\.gradle(?:\.kts)?$/.test(f));
     const buildFiles = [...new Set([
             ...(await existingFiles(root, ["app/build.gradle", "app/build.gradle.kts", "build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"])),
             ...gradleScripts,
         ])];
-    const versionCatalogFiles = (await findFiles(root, [".toml"], 50)).filter((f) => /(?:^|[\\/])gradle[\\/].*\.versions\.toml$/.test(f));
+    const versionCatalogFiles = (await findFiles(root, [".toml"], 50, scanContext, "android.version-catalogs")).filter((f) => /(?:^|[\\/])gradle[\\/].*\.versions\.toml$/.test(f));
     const buildContent = await readMany(buildFiles);
     const versionCatalogContent = await readMany(versionCatalogFiles);
-    const sourceFiles = await findFiles(root, [".kt", ".java"], 300);
+    const sourceFiles = await findFiles(root, [".kt", ".java"], 300, scanContext, "android.source");
     const sourceContent = await readMany(sourceFiles);
     const setupFiles = filesMatching(sourceContent, [/AmityCoreClient\s*\.\s*setup/, /AmityClient\s*\.\s*setup/, /AmityUIKit\d*Manager\s*\.\s*setup/]);
     const coreLoginFiles = filesMatching(sourceContent, [/AmityCoreClient\s*\.\s*login/, /AmityClient\s*\.\s*login/]);
@@ -518,11 +590,11 @@ async function validateAndroid(root) {
     findings.push(...(await validateEnvSecretHygiene(root, "android", sourceContent)));
     return findings;
 }
-async function validateFlutter(root) {
+async function validateFlutter(root, scanContext) {
     const findings = [];
     const pubspec = await readIfExists(path.join(root, "pubspec.yaml"));
     const pubspecLock = await readIfExists(path.join(root, "pubspec.lock"));
-    const dartFiles = await findFiles(path.join(root, "lib"), [".dart"], 300);
+    const dartFiles = await findFiles(path.join(root, "lib"), [".dart"], 300, scanContext, "flutter.source");
     const dartContent = await readMany(dartFiles);
     const setupFiles = filesMatching(dartContent, [/AmityCoreClient\s*\.\s*setup/, /AmityUIKit\d*Manager\s*\.\s*setup/]);
     const coreLoginFiles = filesMatching(dartContent, [/AmityCoreClient\s*\.\s*login/]);
@@ -643,10 +715,10 @@ async function validateFlutter(root) {
     findings.push(...(await validateEnvSecretHygiene(root, "flutter", dartContent)));
     return findings;
 }
-async function validateTypeScript(root, platform) {
+async function validateTypeScript(root, platform, scanContext) {
     const findings = [];
     const packageJson = await readIfExists(path.join(root, "package.json"));
-    const sourceFiles = await findFiles(root, [".ts", ".tsx", ".js", ".jsx"], 500);
+    const sourceFiles = await findFiles(root, [".ts", ".tsx", ".js", ".jsx"], 500, scanContext, `${platform}.source`);
     const sourceContent = await readMany(sourceFiles);
     const setupFiles = filesMatching(sourceContent, [/Client\s*\.\s*createClient/, /Client\s*\.\s*create\s*\(/, /createClient\s*\(/, /Amity(?:UIKit|UiKit)Provider/]);
     const rawLoginFiles = filesMatching(sourceContent, [/Client\s*\.\s*login/, /\.login\s*\(/]);
@@ -3252,7 +3324,7 @@ function iosAmitySdkIsFloating(s) {
         return true;
     return false;
 }
-async function validateIos(root) {
+async function validateIos(root, scanContext) {
     const findings = [];
     const joinExisting = async (names) => [...(await readMany(await existingFiles(root, names))).values()].join("\n");
     const podText = await joinExisting(["Podfile"]);
@@ -3277,7 +3349,7 @@ async function validateIos(root) {
     ];
     const manifestCombined = [podText, pkgSwiftText, projectYmlText, pbxprojText].join("\n");
     const hasManifest = manifestCombined.trim().length > 0;
-    const swiftFiles = await findFiles(root, [".swift", ".xcconfig", ".plist"], 400);
+    const swiftFiles = await findFiles(root, [".swift", ".xcconfig", ".plist"], 400, scanContext, "ios.source");
     const swiftContent = await readMany(swiftFiles);
     const setupFiles = filesMatching(swiftContent, [/AmityClient\s*\(/, /AmityClient\s*\.\s*setup/, /AmityUIKit\d*Manager\s*\.\s*setup/]);
     const coreLoginFiles = filesMatching(swiftContent, [/\.login\s*\(/, /client\.login\s*\(/]);
@@ -3603,10 +3675,11 @@ function inferDesignKind(relativePath) {
     }
     return "theme";
 }
-async function findFiles(root, extensions, maxFiles) {
+async function findFiles(root, extensions, maxFiles, scanContext, scope = "source") {
     const found = [];
+    let truncated = false;
     async function walk(directory) {
-        if (found.length >= maxFiles) {
+        if (truncated) {
             return;
         }
         let entries;
@@ -3616,8 +3689,8 @@ async function findFiles(root, extensions, maxFiles) {
         catch {
             return;
         }
-        for (const entry of entries) {
-            if (found.length >= maxFiles) {
+        for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+            if (truncated) {
                 return;
             }
             if (shouldSkipDirectory(entry.name)) {
@@ -3628,11 +3701,25 @@ async function findFiles(root, extensions, maxFiles) {
                 await walk(entryPath);
             }
             else if (extensions.some((extension) => entry.name.endsWith(extension))) {
+                if (found.length >= maxFiles) {
+                    truncated = true;
+                    return;
+                }
                 found.push(entryPath);
             }
         }
     }
     await walk(root);
+    if (scanContext) {
+        scanContext.scans.push({
+            scope,
+            root: path.relative(scanContext.validationRoot, root) || ".",
+            extensions: [...extensions],
+            scanned: found.length,
+            limit: maxFiles,
+            truncated,
+        });
+    }
     return found;
 }
 async function readMany(files) {
@@ -4151,7 +4238,7 @@ function validateCustomPostTypeDataTypeDeclared(root, platform, sourceContent) {
         if (!matches)
             continue;
         for (const match of matches) {
-            if (/data\s*[:=(]\s*[\{\[]\s*['"]?text['"]?\s*:/i.test(match))
+            if (/data\s*[:=(]\s*[\{\[]\s*['"]?text['"]?\s*(?::|[,}])/i.test(match))
                 continue;
             if (!/dataType\s*[:=\(]/i.test(match)) {
                 findings.push(finding(ruleId, "warning", `File ${rel} creates a custom data post but does not declare a dataType.`, rel, `When creating a post with a custom data payload, the 'dataType' tag must be explicitly provided so the SDK can route it correctly. If missing, it defaults to a text post, which stringifies the payload.`));
@@ -4221,8 +4308,8 @@ function validatePostBodyRendered(root, platform, sourceContent) {
         android: /\b(?:Text\s*\(|TextView|\.text\s*=|setText\s*\()/,
     };
     const postSummaryPat = {
-        typescript: /\bpost\s*\??\.\s*(?:postId|commentsCount|reactionsCount)\b|\bpostId\b/,
-        "react-native": /\bpost\s*\??\.\s*(?:postId|commentsCount|reactionsCount)\b|\bpostId\b/,
+        typescript: /\bpost\s*\??\.\s*(?:postId|commentsCount|reactionsCount)\b/,
+        "react-native": /\bpost\s*\??\.\s*(?:postId|commentsCount|reactionsCount)\b/,
         flutter: /\b(?:post|_posts\s*\[[^\]]+\])\s*\.\s*(?:postId|commentsCount|reactionsCount)\b/,
         ios: /\bpost\s*\.\s*(?:postId|commentsCount|reactionsCount)\b/,
         android: /\bpost\s*\.\s*(?:postId|commentsCount|reactionsCount|getPostId|getCommentCount|getReactionCount)\b/,

package/dist/tools/sdkFacts.js

@@ -70,6 +70,119 @@ const CAPABILITIES = {
         ],
         models: [{ name: "Post", kind: "model", owner: "Amity" }],
     },
+    community: {
+        required: [
+            { name: "CommunityRepository", kind: "type" },
+            { name: "getCommunities", kind: "member", owner: "CommunityRepository" },
+            { name: "joinCommunity", kind: "member", owner: "CommunityRepository" },
+        ],
+        optional: [
+            { name: "getCommunity", kind: "member", owner: "CommunityRepository" },
+            { name: "createCommunity", kind: "member", owner: "CommunityRepository" },
+            { name: "leaveCommunity", kind: "member", owner: "CommunityRepository" },
+            { name: "updateCommunity", kind: "member", owner: "CommunityRepository" },
+            { name: "deleteCommunity", kind: "member", owner: "CommunityRepository" },
+            { name: "searchCommunities", kind: "member", owner: "CommunityRepository" },
+            { name: "getRecommendedCommunities", kind: "member", owner: "CommunityRepository" },
+            { name: "getTrendingCommunities", kind: "member", owner: "CommunityRepository" },
+            { name: "onCommunityCreated", kind: "member", owner: "CommunityRepository" },
+            { name: "onCommunityUpdated", kind: "member", owner: "CommunityRepository" },
+            { name: "onCommunityDeleted", kind: "member", owner: "CommunityRepository" },
+        ],
+        models: [{ name: "Community", kind: "model", owner: "Amity" }],
+    },
+    chat: {
+        required: [
+            { name: "ChannelRepository", kind: "type" },
+            { name: "MessageRepository", kind: "type" },
+            { name: "getChannels", kind: "member", owner: "ChannelRepository" },
+            { name: "getMessages", kind: "member", owner: "MessageRepository" },
+            { name: "createMessage", kind: "member", owner: "MessageRepository" },
+        ],
+        optional: [
+            { name: "getChannel", kind: "member", owner: "ChannelRepository" },
+            { name: "createChannel", kind: "member", owner: "ChannelRepository" },
+            { name: "joinChannel", kind: "member", owner: "ChannelRepository" },
+            { name: "leaveChannel", kind: "member", owner: "ChannelRepository" },
+            { name: "archiveChannel", kind: "member", owner: "ChannelRepository" },
+            { name: "unarchiveChannel", kind: "member", owner: "ChannelRepository" },
+            { name: "muteChannel", kind: "member", owner: "ChannelRepository" },
+            { name: "searchChannels", kind: "member", owner: "ChannelRepository" },
+            { name: "getSubChannels", kind: "member", owner: "SubChannelRepository" },
+            { name: "editMessage", kind: "member", owner: "MessageRepository" },
+            { name: "deleteMessage", kind: "member", owner: "MessageRepository" },
+            { name: "flagMessage", kind: "member", owner: "MessageRepository" },
+            { name: "unflagMessage", kind: "member", owner: "MessageRepository" },
+            { name: "isMessageFlaggedByMe", kind: "member", owner: "MessageRepository" },
+            { name: "searchMessage", kind: "member", owner: "MessageRepository" },
+            { name: "markAsDelivered", kind: "member", owner: "MessageRepository" },
+            { name: "onMessageCreatedMqtt", kind: "member", owner: "MessageRepository" },
+            { name: "onMessageUpdated", kind: "member", owner: "MessageRepository" },
+            { name: "onMessageDeleted", kind: "member", owner: "MessageRepository" },
+        ],
+        models: [
+            { name: "Channel", kind: "model", owner: "Amity" },
+            { name: "Message", kind: "model", owner: "Amity" },
+            { name: "SubChannel", kind: "model", owner: "Amity" },
+        ],
+    },
+    livestream: {
+        required: [
+            { name: "RoomRepository", kind: "type" },
+            { name: "getRoom", kind: "member", owner: "RoomRepository" },
+            { name: "getRooms", kind: "member", owner: "RoomRepository" },
+        ],
+        optional: [
+            { name: "createRoom", kind: "member", owner: "RoomRepository" },
+            { name: "updateRoom", kind: "member", owner: "RoomRepository" },
+            { name: "deleteRoom", kind: "member", owner: "RoomRepository" },
+            { name: "leaveRoom", kind: "member", owner: "RoomRepository" },
+            { name: "stopRoom", kind: "member", owner: "RoomRepository" },
+            { name: "removeParticipant", kind: "member", owner: "RoomRepository" },
+            { name: "getBroadcasterData", kind: "member", owner: "RoomRepository" },
+            { name: "getRecordedUrl", kind: "member", owner: "RoomRepository" },
+            { name: "getPlayer", kind: "member", owner: "LiveStreamPlayer" },
+            { name: "getRoomOnlineUsers", kind: "member", owner: "RoomPresenceRepository" },
+            { name: "getRoomUserCount", kind: "member", owner: "RoomPresenceRepository" },
+        ],
+        models: [{ name: "Room", kind: "model", owner: "Amity" }],
+    },
+    "notification-tray": {
+        required: [
+            { name: "notificationTray", kind: "type" },
+            { name: "getNotificationTrayItems", kind: "member", owner: "notificationTray" },
+        ],
+        optional: [
+            { name: "getNotificationTraySeen", kind: "member", owner: "notificationTray" },
+            { name: "markItemsSeen", kind: "member", owner: "notificationTray" },
+            { name: "markTraySeen", kind: "member", owner: "notificationTray" },
+            { name: "onNotificationTraySeenUpdated", kind: "member", owner: "notificationTray" },
+        ],
+        models: [
+            { name: "NotificationTrayItem", kind: "model", owner: "Amity" },
+            { name: "NotificationTraySeen", kind: "model", owner: "Amity" },
+        ],
+    },
+    events: {
+        required: [
+            { name: "EventRepository", kind: "type" },
+            { name: "getEvents", kind: "member", owner: "EventRepository" },
+            { name: "getRSVPs", kind: "member", owner: "EventRepository" },
+        ],
+        optional: [
+            { name: "getEvent", kind: "member", owner: "EventRepository" },
+            { name: "getMyEvents", kind: "member", owner: "EventRepository" },
+            { name: "createEvent", kind: "member", owner: "EventRepository" },
+            { name: "updateEvent", kind: "member", owner: "EventRepository" },
+            { name: "deleteEvent", kind: "member", owner: "EventRepository" },
+            { name: "onEventCreated", kind: "member", owner: "EventRepository" },
+            { name: "onEventUpdated", kind: "member", owner: "EventRepository" },
+            { name: "onEventDeleted", kind: "member", owner: "EventRepository" },
+            { name: "onRSVPCreated", kind: "member", owner: "EventRepository" },
+            { name: "onRSVPUpdated", kind: "member", owner: "EventRepository" },
+        ],
+        models: [{ name: "Event", kind: "model", owner: "Amity" }],
+    },
     users: {
         required: [
             { name: "UserRepository", kind: "type" },
@@ -88,6 +201,113 @@ const CAPABILITIES = {
         models: [{ name: "User", kind: "model", owner: "Amity" }],
     },
 };
+const FLUTTER_CAPABILITIES = {
+    comments: {
+        required: [
+            { name: "CommentRepository", kind: "type" },
+            { name: "getComments", kind: "member", owner: "CommentRepository" },
+            { name: "createComment", kind: "member", owner: "CommentRepository" },
+        ],
+        optional: [
+            { name: "getComment", kind: "member", owner: "CommentRepository" },
+            { name: "updateComment", kind: "member", owner: "CommentRepository" },
+        ],
+        models: [{ name: "AmityComment", kind: "model" }],
+    },
+    reactions: {
+        required: [
+            { name: "AmityReactionRepository", kind: "type" },
+            { name: "addReaction", kind: "member", owner: "AmityReactionRepository" },
+            { name: "removeReaction", kind: "member", owner: "AmityReactionRepository" },
+        ],
+        optional: [
+            { name: "getReactions", kind: "member", owner: "AmityReactionRepository" },
+        ],
+        models: [{ name: "AmityReaction", kind: "model" }],
+    },
+    posts: {
+        required: [
+            { name: "PostRepository", kind: "type" },
+            { name: "getPosts", kind: "member", owner: "PostRepository" },
+            { name: "createPost", kind: "member", owner: "PostRepository" },
+        ],
+        optional: [
+            { name: "getPost", kind: "member", owner: "PostRepository" },
+            { name: "deletePost", kind: "member", owner: "PostRepository" },
+            { name: "reviewPost", kind: "member", owner: "PostRepository" },
+            { name: "getPinnedPosts", kind: "member", owner: "PostRepository" },
+            { name: "isFlaggedByMe", kind: "member", owner: "PostRepository" },
+        ],
+        models: [{ name: "AmityPost", kind: "model" }],
+    },
+    users: {
+        required: [
+            { name: "UserRepository", kind: "type" },
+            { name: "getUser", kind: "member", owner: "UserRepository" },
+        ],
+        optional: [
+            { name: "getUsers", kind: "member", owner: "UserRepository" },
+            { name: "searchUserByDisplayName", kind: "member", owner: "UserRepository" },
+            { name: "updateUser", kind: "member", owner: "UserRepository" },
+            { name: "getBlockedUsers", kind: "member", owner: "UserRepository" },
+            { name: "report", kind: "member", owner: "UserRepository" },
+            { name: "follow", kind: "member", owner: "AmityUserRelationshipRepository" },
+            { name: "getFollowInfo", kind: "member", owner: "AmityUserRelationshipRepository" },
+        ],
+        models: [{ name: "AmityUser", kind: "model" }],
+    },
+    community: {
+        required: [
+            { name: "AmityCommunityRepository", kind: "type" },
+            { name: "getCommunities", kind: "member", owner: "AmityCommunityRepository" },
+            { name: "joinCommunity", kind: "member", owner: "AmityCommunityRepository" },
+        ],
+        optional: [
+            { name: "getCommunity", kind: "member", owner: "AmityCommunityRepository" },
+            { name: "createCommunity", kind: "member", owner: "AmityCommunityRepository" },
+            { name: "leaveCommunity", kind: "member", owner: "AmityCommunityRepository" },
+            { name: "updateCommunity", kind: "member", owner: "AmityCommunityRepository" },
+            { name: "deleteCommunity", kind: "member", owner: "AmityCommunityRepository" },
+            { name: "getRecommendedCommunities", kind: "member", owner: "AmityCommunityRepository" },
+            { name: "getTrendingCommunities", kind: "member", owner: "AmityCommunityRepository" },
+        ],
+        models: [{ name: "AmityCommunity", kind: "model" }],
+    },
+    chat: {
+        required: [
+            { name: "AmityChannelRepository", kind: "type" },
+            { name: "MessageRepository", kind: "type" },
+            { name: "getChannels", kind: "member", owner: "AmityChannelRepository" },
+            { name: "getMessages", kind: "member", owner: "MessageRepository" },
+            { name: "createMessage", kind: "member", owner: "MessageRepository" },
+        ],
+        optional: [
+            { name: "getChannel", kind: "member", owner: "AmityChannelRepository" },
+            { name: "createChannel", kind: "member", owner: "AmityChannelRepository" },
+            { name: "joinChannel", kind: "member", owner: "AmityChannelRepository" },
+            { name: "leaveChannel", kind: "member", owner: "AmityChannelRepository" },
+            { name: "archiveChannel", kind: "member", owner: "AmityChannelRepository" },
+            { name: "unarchiveChannel", kind: "member", owner: "AmityChannelRepository" },
+            { name: "muteChannel", kind: "member", owner: "AmityChannelRepository" },
+            { name: "searchChannels", kind: "member", owner: "AmityChannelRepository" },
+            { name: "getMessage", kind: "member", owner: "MessageRepository" },
+            { name: "deleteMessage", kind: "member", owner: "MessageRepository" },
+            { name: "flagMessage", kind: "member", owner: "MessageRepository" },
+            { name: "updateMessage", kind: "member", owner: "MessageRepository" },
+            { name: "searchMessage", kind: "member", owner: "MessageRepository" },
+            { name: "getSubChannels", kind: "member", owner: "AmitySubChannelRepository" },
+        ],
+        models: [
+            { name: "AmityChannel", kind: "model" },
+            { name: "AmityMessage", kind: "model" },
+            { name: "AmitySubChannel", kind: "model" },
+        ],
+    },
+};
+const CAPABILITY_ANCHORS = {
+    typescript: CAPABILITIES,
+    flutter: FLUTTER_CAPABILITIES,
+};
 export const getSdkFactsTool = {
     name: "get_sdk_facts",
     description: "Read bundled social.plus SDK surface facts for block packaging. Projectless and read-only; answers symbol existence, not semantic correctness.",
@@ -181,7 +401,12 @@ export async function getSdkFacts(options) {
             "Remote SP_SDK_SURFACE_URL resolution is recorded in the manifest for a future online snapshot source; this MVP uses local override/env/bundled directories only.",
             ...(platform !== "typescript"
                 ? [
-                    `Capability anchors are authored TypeScript-first at this MVP, so capabilities is empty for ${platform}. This means capability mapping is not yet available on ${platform} — it does NOT mean the SDK lacks the feature. The symbol and model facts above are extracted from the ${platform} surface and remain authoritative.`,
+                    (() => {
+                        const anchored = Object.keys(CAPABILITY_ANCHORS[platform] ?? {});
+                        return anchored.length > 0
+                            ? `Capability anchors on ${platform} cover: ${anchored.join(", ")}. Families not listed are not yet anchored on ${platform} — capability mapping is unavailable for them, which does NOT mean the SDK lacks the feature. The symbol and model facts above are extracted from the ${platform} surface and remain authoritative.`
+                            : `Capability anchors are authored TypeScript-first at this MVP, so capabilities is empty for ${platform}. This means capability mapping is not yet available on ${platform} — it does NOT mean the SDK lacks the feature. The symbol and model facts above are extracted from the ${platform} surface and remain authoritative.`;
+                    })(),
                 ]
                 : []),
         ],
@@ -264,20 +489,21 @@ async function readJson(filePath) {
 }
 function requestedCapabilityIds(platform, capability) {
     const available = Object.keys(CAPABILITIES);
+    const anchored = Object.keys(CAPABILITY_ANCHORS[platform] ?? {});
     if (!capability) {
-        return platform === "typescript" ? available : [];
+        return anchored;
     }
     const normalized = capability.trim().toLowerCase();
     if (!available.includes(normalized)) {
         throw new Error(`Unsupported SDK capability: ${capability}. Supported capabilities: ${available.join(", ")}.`);
     }
-    if (platform !== "typescript") {
-        return [];
-    }
-    return [normalized];
+    return anchored.includes(normalized) ? [normalized] : [];
 }
 function buildCapabilityFact(id, platform, symbols, modelFacts) {
-    const definition = CAPABILITIES[id];
+    const definition = CAPABILITY_ANCHORS[platform]?.[id];
+    if (!definition) {
+        throw new Error(`No ${platform} anchor set for capability ${id}; requestedCapabilityIds must filter unanchored families.`);
+    }
     const requiredSymbols = definition.required.map((symbol) => checkSymbol(symbols, { ...symbol, required: true }));
     const optionalSymbols = definition.optional.map((symbol) => checkSymbol(symbols, { ...symbol, required: false }));
     const models = definition.models.map((symbol) => {