@amityco/social-plus-vise 0.4.0 → 0.8.0

package/dist/outcomes.js

@@ -5,6 +5,9 @@ export function hasAnswer(answers, id) {
 const CLASSIFY_ORDER = [
     "setup-push",
     "setup-live-data",
+    "add-moderation",
+    "add-chat",
+    "add-comments",
     "add-feed",
     "troubleshoot",
     "validate-setup",
@@ -17,6 +20,15 @@ const LIVE_PATTERNS = [
 const FEED_PATTERNS = [
     /\b(social feature|social features|feed|timeline|post list|news feed|create post|create a post|post creation|compose post)\b/,
 ];
+const COMMENT_PATTERNS = [
+    /\b(comment|comments|reply|replies|thread|discussion thread|comment composer)\b/,
+];
+const MODERATION_OUTCOME_PATTERNS = [
+    /\b(moderation|report|flag|block user|mute user|hide content|abuse|review queue|admin queue)\b/,
+];
+const CHAT_PATTERNS = [
+    /\b(chat|messaging|dm|direct message|conversation|group chat|channel|inbox)\b/,
+];
 const TROUBLESHOOT_PATTERNS = [/\b(error|broken|crash|not working|fail|timeout|401|403)\b/];
 const VALIDATE_PATTERNS = [/\b(validate|check|correct|setup right|initiali[sz])\b/];
 const SETUP_PATTERNS = [/\b(setup|set up|install|integrate|wire|configure)\b/];
@@ -485,6 +497,367 @@ const addFeed = {
     ],
     resolveNotes: () => [],
 };
+function commentDocPath(platform) {
+    const paths = {
+        android: "social-plus-sdk/social/comments/android",
+        flutter: "social-plus-sdk/social/comments/flutter",
+        ios: "social-plus-sdk/social/comments/ios",
+        typescript: "social-plus-sdk/social/comments/typescript",
+        "react-native": "social-plus-sdk/social/comments/typescript",
+    };
+    return paths[platform] ?? "social-plus-sdk/social/comments";
+}
+const addComments = {
+    id: "add-comments",
+    patterns: COMMENT_PATTERNS,
+    interpretation: "Add a comments/replies surface to an existing post or content entity using the customer app's design system.",
+    docsQuery: (platform) => `${platform} social comments replies`,
+    docs: (platform) => [
+        {
+            path: commentDocPath(platform),
+            reason: "Canonical comment/reply API, query patterns, and lifecycle guidance.",
+        },
+        {
+            path: "social-plus-sdk/social/comments",
+            reason: "Comment concepts overview: threading, moderation, and target types.",
+        },
+        {
+            path: liveDataPlatformPath(platform),
+            reason: "Platform-specific Live Object and Live Collection implementation for real-time comment updates.",
+        },
+    ],
+    intakeQuestions: (ctx) => {
+        const questions = [
+            {
+                id: "comment_target",
+                question: "What content type should comments attach to (post, story, custom entity)?",
+                why: "Comments must reference a concrete parent. The coding agent must not invent postId or targetId values.",
+                required: true,
+                blocksImplementationWhenMissing: true,
+                options: ["post", "story", "custom entity"],
+            },
+            {
+                id: "comment_depth",
+                question: "Should comments support threaded replies? If yes, what is the maximum depth?",
+                why: "Threaded comments require different query strategy and UI rendering. Unbounded depth creates recursion risk.",
+                required: true,
+                blocksImplementationWhenMissing: true,
+                options: ["flat (no threading)", "one level of replies", "multi-level (specify depth)"],
+            },
+            {
+                id: "moderation_flow",
+                question: "What moderation actions should be available on comments (report, delete, hide)?",
+                why: "Comments are user-generated content and need a moderation affordance path.",
+                required: true,
+                blocksImplementationWhenMissing: false,
+            },
+            {
+                id: "lifecycle_owner",
+                question: "What owns the lifecycle of the live comment subscription (Activity, ViewController, Widget, React component)?",
+                why: "Live comment observers must be cleaned up to prevent memory leaks and stale updates.",
+                required: true,
+                blocksImplementationWhenMissing: true,
+            },
+            {
+                id: "target_screen",
+                question: "Which screen or component should display comments?",
+                why: "Vise needs to know the target file/route for comment UI placement.",
+                required: true,
+                blocksImplementationWhenMissing: true,
+            },
+        ];
+        return filterAnswered(ctx.answers, questions);
+    },
+    requiredInputs: () => [
+        "comment target type: post, story, or custom entity",
+        "concrete parent entity ID or selection flow",
+        "comment depth: flat or threaded with max depth",
+        "lifecycle owner for comment observer cleanup",
+        "target screen or component for comment UI",
+    ],
+    implementationRules: () => [
+        "Do not invent or hardcode postId, commentId, or any comment target. Ask for the target or implement a parent-entity-owned flow.",
+        "Do not ask for API keys in chat. Create an env/config placeholder.",
+        "Comment observers must be cleaned up when the lifecycle owner is destroyed.",
+        "Threaded comments must respect the declared max depth.",
+    ],
+    implementationSteps: (ctx) => {
+        const designEvidence = ctx.designSignals.length > 0
+            ? ctx.designSignals.map((signal) => signal.file)
+            : ["requiredInputs.design token or theme source file"];
+        return [
+            {
+                step: "Confirm the parent entity (post/story), target screen, and threading depth before writing code.",
+                evidence: [
+                    "requiredInputs.comment target type",
+                    "requiredInputs.comment depth",
+                    "requiredInputs.target screen or component",
+                ],
+            },
+            {
+                step: "Fetch comment docs and implement the comment query using platform live collection patterns.",
+                evidence: [commentDocPath(ctx.platform), liveDataPlatformPath(ctx.platform)],
+            },
+            { step: "Reuse the host app's existing visual system for the comment UI.", evidence: designEvidence },
+            { step: "Implement loading, empty, error, and data states for comments.", evidence: ["implementationRules.file-specific edits"] },
+            { step: "Add comment creation (composer) with auth gate and error handling.", evidence: ["requiredInputs.concrete parent entity ID"] },
+            { step: "Wire moderation affordance (report/hide/delete) on each comment.", evidence: ["implementationRules.file-specific edits"] },
+            { step: "Run validate_setup and detected command sensors after edits.", evidence: ["validate_setup", "run_sensors"] },
+        ];
+    },
+    validation: (platform) => [
+        "comment target resolved",
+        "no invented postId/commentId",
+        `${platform}.comments.target-resolved`,
+        `${platform}.comments.observer-cleanup`,
+        `${platform}.comments.ui-states-present`,
+        `${platform}.comments.moderation-affordance-present`,
+    ],
+    stopConditions: (ctx) => filterStops(ctx.answers, [
+        { id: "comment_target", text: "The comment target entity is unknown; do not invent postId, commentId, or parent entity references." },
+        { id: "comment_depth", text: "The threading depth is unknown; cannot implement comment query or UI without knowing if replies are flat or nested." },
+        { id: "lifecycle_owner", text: "The lifecycle owner for comment observer cleanup is unknown." },
+        { id: "moderation_flow", text: "The moderation flow for comments is unknown; comments are UGC and need report/block/hide." },
+    ]),
+    resolvePlan: () => [
+        { file: "Target screen/component", intent: "Add comment query, render list with loading/empty/error/data states." },
+        { file: "Comment composer", intent: "Add comment creation flow with auth gate." },
+        { file: "Moderation", intent: "Add report/hide/delete affordance on each comment." },
+    ],
+    resolveVerification: () => [
+        "Confirm comments load from the correct parent entity.",
+        "Confirm comment observer is cleaned up on lifecycle end.",
+        "Confirm threading respects declared depth limit.",
+        "Confirm moderation affordance is present.",
+    ],
+    resolveNotes: () => [],
+};
+const addModeration = {
+    id: "add-moderation",
+    patterns: MODERATION_OUTCOME_PATTERNS,
+    interpretation: "Add moderation capabilities (report, block, mute, hide) to social content.",
+    docsQuery: (platform) => `${platform} moderation report flag block`,
+    docs: (platform) => [
+        {
+            path: "social-plus-sdk/social/moderation",
+            reason: "Moderation concepts: report, block, mute, hide content, and admin review.",
+        },
+        {
+            path: liveDataPlatformPath(platform),
+            reason: "Platform-specific patterns for observing moderation state changes.",
+        },
+    ],
+    intakeQuestions: (ctx) => {
+        const questions = [
+            {
+                id: "moderation_target",
+                question: "What content types need moderation (post, comment, message, user)?",
+                why: "Each content type has different moderation APIs and UI patterns.",
+                required: true,
+                blocksImplementationWhenMissing: true,
+                options: ["posts", "comments", "messages", "users", "all"],
+            },
+            {
+                id: "moderation_actions",
+                question: "Which moderation actions should be available (report, block, mute, hide, admin queue)?",
+                why: "The action set determines API calls and UI affordances needed.",
+                required: true,
+                blocksImplementationWhenMissing: true,
+            },
+            {
+                id: "admin_ownership",
+                question: "Who owns the admin/review queue for reported content?",
+                why: "Admin moderation may live in a separate dashboard or external service.",
+                required: false,
+                blocksImplementationWhenMissing: false,
+            },
+            {
+                id: "post_action_rendering",
+                question: "How should moderated content appear to the user (hidden, placeholder, blurred)?",
+                why: "Customer policy determines whether blocked/hidden content shows a placeholder or disappears entirely.",
+                required: true,
+                blocksImplementationWhenMissing: false,
+            },
+        ];
+        return filterAnswered(ctx.answers, questions);
+    },
+    requiredInputs: () => [
+        "moderation target types: post, comment, message, user",
+        "moderation action set: report, block, mute, hide, admin queue",
+        "post-action rendering policy for blocked/hidden content",
+    ],
+    implementationRules: () => [
+        "Do not implement moderation without knowing the target content types.",
+        "Report actions must include confirmation UI before submission.",
+        "Blocked/muted state must be applied to the rendered UI, not just stored.",
+    ],
+    implementationSteps: (ctx) => {
+        const designEvidence = ctx.designSignals.length > 0
+            ? ctx.designSignals.map((signal) => signal.file)
+            : ["requiredInputs.design token or theme source file"];
+        return [
+            {
+                step: "Confirm moderation targets, actions, and rendering policy before writing code.",
+                evidence: ["requiredInputs.moderation target types", "requiredInputs.moderation action set"],
+            },
+            {
+                step: "Implement report flow with confirmation UX.",
+                evidence: ["social-plus-sdk/social/moderation"],
+            },
+            { step: "Implement block/mute state application to rendered content.", evidence: designEvidence },
+            { step: "Add hidden/blocked content rendering per customer policy.", evidence: ["requiredInputs.post-action rendering policy"] },
+            { step: "Run validate_setup and detected command sensors after edits.", evidence: ["validate_setup", "run_sensors"] },
+        ];
+    },
+    validation: (platform) => [
+        `${platform}.moderation.report-flow-present`,
+        `${platform}.moderation.block-or-mute-state-applied`,
+        `${platform}.moderation.hidden-content-rendering-present`,
+        `${platform}.moderation.confirmation-ux-present`,
+    ],
+    stopConditions: (ctx) => filterStops(ctx.answers, [
+        { id: "moderation_target", text: "The moderation target content types are unknown." },
+        { id: "moderation_actions", text: "The moderation action set is unknown; cannot implement without knowing which actions are needed." },
+    ]),
+    resolvePlan: () => [
+        { file: "Report UI", intent: "Add report flow with confirmation dialog." },
+        { file: "Content rendering", intent: "Apply blocked/muted/hidden state to rendered items." },
+        { file: "Moderation actions", intent: "Wire block/mute/hide actions to SDK calls." },
+    ],
+    resolveVerification: () => [
+        "Confirm report flow includes confirmation before submission.",
+        "Confirm blocked/muted content renders according to customer policy.",
+        "Confirm moderation actions are wired to correct SDK APIs.",
+    ],
+    resolveNotes: () => [],
+};
+const addChat = {
+    id: "add-chat",
+    patterns: CHAT_PATTERNS,
+    interpretation: "Add chat/messaging capabilities using the customer app's design system.",
+    docsQuery: (platform) => `${platform} chat messaging channel`,
+    docs: (platform) => [
+        {
+            path: "social-plus-sdk/chat/channels",
+            reason: "Chat channel concepts: creation, types (1:1, group, community), and member management.",
+        },
+        {
+            path: "social-plus-sdk/chat/messages",
+            reason: "Message send/receive, observer lifecycle, delivery state, and moderation.",
+        },
+        {
+            path: liveDataPlatformPath(platform),
+            reason: "Platform-specific Live Object/Collection patterns for real-time message updates.",
+        },
+    ],
+    intakeQuestions: (ctx) => {
+        const questions = [
+            {
+                id: "chat_shape",
+                question: "What chat shape is needed (1:1, group, community channel)?",
+                why: "Determines channel creation strategy and query patterns.",
+                required: true,
+                blocksImplementationWhenMissing: true,
+                options: ["1:1 direct message", "group chat", "community channel"],
+            },
+            {
+                id: "channel_source",
+                question: "How are channels/conversations created or discovered?",
+                why: "Avoids invented channel IDs. Channels come from user selection, SDK query, or app logic.",
+                required: true,
+                blocksImplementationWhenMissing: true,
+            },
+            {
+                id: "message_capabilities",
+                question: "Which message capabilities are needed (send, read, edit, delete, reactions)?",
+                why: "Determines the scope of SDK calls and UI affordances.",
+                required: true,
+                blocksImplementationWhenMissing: true,
+                options: ["send only", "send + read", "full (send/read/edit/delete/react)"],
+            },
+            {
+                id: "read_receipts",
+                question: "Should read receipts be shown?",
+                why: "Read receipts require additional SDK subscriptions and cleanup.",
+                required: true,
+                blocksImplementationWhenMissing: false,
+                options: ["yes", "no"],
+            },
+            {
+                id: "typing_indicators",
+                question: "Should typing indicators be shown?",
+                why: "Typing indicators require observer lifecycle management.",
+                required: true,
+                blocksImplementationWhenMissing: false,
+                options: ["yes", "no"],
+            },
+            {
+                id: "moderation_flow",
+                question: "What moderation actions are needed for chat messages?",
+                why: "Chat messages are UGC and need report/block/mute affordance.",
+                required: true,
+                blocksImplementationWhenMissing: false,
+            },
+        ];
+        return filterAnswered(ctx.answers, questions);
+    },
+    requiredInputs: () => [
+        "chat shape: 1:1, group, or community channel",
+        "channel source: how channels are created or discovered",
+        "message capabilities scope",
+        "read receipt and typing indicator requirements",
+        "moderation flow for chat messages",
+    ],
+    implementationRules: () => [
+        "Do not invent or hardcode channelId, conversationId, or member lists.",
+        "Message observers must be cleaned up when the chat view is dismissed.",
+        "Typing indicator subscriptions must be cleaned up on view disposal.",
+        "Read receipt marking must only fire when messages are actually displayed.",
+    ],
+    implementationSteps: (ctx) => {
+        const designEvidence = ctx.designSignals.length > 0
+            ? ctx.designSignals.map((signal) => signal.file)
+            : ["requiredInputs.design token or theme source file"];
+        return [
+            {
+                step: "Confirm chat shape, channel source, and capabilities before writing code.",
+                evidence: ["requiredInputs.chat shape", "requiredInputs.channel source", "requiredInputs.message capabilities scope"],
+            },
+            {
+                step: "Implement channel query/creation and message observation with lifecycle cleanup.",
+                evidence: ["social-plus-sdk/chat/channels", "social-plus-sdk/chat/messages"],
+            },
+            { step: "Reuse the host app's existing visual system for chat UI.", evidence: designEvidence },
+            { step: "Add message send with error handling and auth gate.", evidence: ["implementationRules.file-specific edits"] },
+            { step: "Wire read receipts and typing indicators if required.", evidence: ["requiredInputs.read receipt and typing indicator requirements"] },
+            { step: "Add moderation affordance on messages.", evidence: ["requiredInputs.moderation flow for chat messages"] },
+            { step: "Run validate_setup and detected command sensors after edits.", evidence: ["validate_setup", "run_sensors"] },
+        ];
+    },
+    validation: (platform) => [
+        `${platform}.chat.channel-target-resolved`,
+        `${platform}.chat.message-observer-cleanup`,
+        `${platform}.chat.send-error-handling`,
+        `${platform}.chat.moderation-affordance-present`,
+    ],
+    stopConditions: (ctx) => filterStops(ctx.answers, [
+        { id: "chat_shape", text: "The chat shape is unknown; cannot implement without knowing 1:1, group, or community channel." },
+        { id: "channel_source", text: "The channel/member source is unknown; do not invent channelId or member lists." },
+        { id: "message_capabilities", text: "The message capabilities scope is unknown." },
+    ]),
+    resolvePlan: () => [
+        { file: "Channel view", intent: "Query/create channel and observe messages with lifecycle cleanup." },
+        { file: "Message composer", intent: "Send messages with error handling and auth gate." },
+        { file: "Message list", intent: "Render messages with read receipts and moderation affordance." },
+    ],
+    resolveVerification: () => [
+        "Confirm channel is queried from a valid source, not invented.",
+        "Confirm message observer is cleaned up on view dismissal.",
+        "Confirm send has error handling.",
+        "Confirm moderation affordance exists on messages.",
+    ],
+    resolveNotes: () => [],
+};
 const troubleshoot = {
     id: "troubleshoot",
     patterns: TROUBLESHOOT_PATTERNS,
@@ -568,6 +941,9 @@ const outcomeRegistry = {
     "setup-push": setupPush,
     "setup-live-data": setupLiveData,
     "add-feed": addFeed,
+    "add-comments": addComments,
+    "add-moderation": addModeration,
+    "add-chat": addChat,
     troubleshoot,
     "validate-setup": validateSetup,
     unknown,