Specif-ai MCP Server

{ "features": [ { "id": "US1", "name": "Enable Live Video Broadcasting for Creators", "description": "Ability to broadcast live video streams. In order to engage with audiences in real-time. As a creator, I want the capability to start and manage a live video broadcast. Acceptance Criteria: The creator dashboard must display a clear 'Start Live Stream' button. The live streaming screen must include options to configure stream title, description, and audience settings. Creators must be able to see the number of viewers in real-time. A 'Stop Live Stream' button should be prominently available during broadcast. If there are connection issues, the system must inform creators with retry and troubleshooting options.", "tasks": [ { "list": "Create 'Start Live Stream' button in creator dashboard", "acceptance": "Add a 'Start Live Stream' button on the creator dashboard using Angular. Ensure that the button is clearly visible and triggers a method to initiate live streaming. Acceptance Criteria: 1) The button is prominently displayed on the dashboard. 2) Clicking the button triggers the live stream initiation logic. 3) The button label is accurately displayed as 'Start Live Stream'.", "id": "TASK1" }, { "list": "Implement live streaming initiation logic in backend", "acceptance": "Create a Rust API endpoint to handle live stream initiation requests. This endpoint should validate creator permissions and prepare necessary streaming session metadata. Acceptance Criteria: 1) The API endpoint processes requests to initiate a live stream. 2) Validations for the creator's authorization and live stream session parameters are implemented. 3) A 200 response with session details is returned upon success. 4) Errors such as unauthorized access or invalid inputs return appropriate HTTP error codes.", "id": "TASK2" }, { "list": "Add live streaming configuration options (title, description, audience settings)", "acceptance": "Update the front-end Angular live streaming screen to display input fields for stream title, description, and audience settings. Bind these fields to the corresponding attributes in the session metadata sent to the backend API. Acceptance Criteria: 1) The stream title, description, and audience settings fields are displayed and functional. 2) The input values are correctly passed to the backend during the 'Start Live Stream' request. 3) Required fields must be validated with appropriate error messages.", "id": "TASK3" }, { "list": "Display real-time viewer count during live stream", "acceptance": "Implement a WebSocket connection between the backend and the Angular front-end to receive real-time viewer count updates. Display the updated count in the streaming UI. Acceptance Criteria: 1) A WebSocket connection is established and listens for viewer count updates. 2) Viewer count updates are displayed in real time on the streaming screen. 3) Handle reconnection logic for WebSocket failures. 4) The viewer count display refreshes without page reloads.", "id": "TASK4" }, { "list": "Add 'Stop Live Stream' button on live streaming screen", "acceptance": "Add a 'Stop Live Stream' button to the Angular live streaming UI. Ensure the button is prominently visible and triggers a backend API call to end the live stream session. Acceptance Criteria: 1) The 'Stop Live Stream' button is displayed during an active session. 2) Clicking the button sends a request to the backend to end the session. 3) The UI transitions back to the dashboard when the session ends successfully.", "id": "TASK5" }, { "list": "Implement backend logic to stop live stream", "acceptance": "Create a Rust API endpoint to handle live stream termination requests. Ensure the endpoint validates the session and updates live-streaming metadata. Acceptance Criteria: 1) The API endpoint processes requests to stop the live stream. 2) The session metadata is correctly updated to reflect session termination. 3) Proper error handling is implemented for invalid or already-terminated sessions. 4) A 200 response is returned upon successful session termination.", "id": "TASK6" }, { "list": "Implement connection issue detection and notifications", "acceptance": "Add logic in the Angular front-end to detect connection interruptions and notify the user with retry and troubleshooting options. Acceptance Criteria: 1) The system detects connection issues during streaming. 2) A notification is displayed to the creator describing the issue. 3) Retry and linkable troubleshooting options are provided within the notification. 4) Ensure the retry functionality resends the appropriate request and re-establishes live streaming or necessary WebSocket functionality.", "id": "TASK7" } ] }, { "id": "US2", "name": "Provide Live Video Viewing with Chat for Viewers", "description": "Ability to watch live streams and engage in live chat. In order to interact with creators during broadcasts. As a viewer, I want the ability to view live video and participate in real-time text-based chat. Acceptance Criteria: The live video page must display the live video stream prominently. A chat panel should be displayed alongside or below the video. Viewers must be able to send and view messages in real-time. The system must automatically load the chat with the latest messages from the beginning of the stream. Messages sent in the chat should appear instantly, maintaining synchronization with the server.", "tasks": [ { "list": "Create video streaming service endpoint in Rust", "acceptance": "Implement a Rust service that serves the live video stream endpoint. Use GCP streaming capabilities, if applicable, to provide the video content. The endpoint must support continuous live streaming and handle stream interruptions gracefully. Acceptance Criteria: The service must stream video data in real-time without latency, and it must recover seamlessly in case of interruptions or errors.", "id": "TASK1" }, { "list": "Implement live chat backend service in Rust", "acceptance": "Develop a Rust microservice for chat functionality that handles sending and receiving of real-time messages. The service must interact with a message queue or pub/sub system (provided by GCP). Messages must be persisted temporarily to synchronize across clients. Acceptance Criteria: The chat backend must handle up to 1,000,000 messages per minute, support multiple clients simultaneously, and ensure that all messages appear instantly to connected users.", "id": "TASK2" }, { "list": "Develop Angular component for live video streaming player", "acceptance": "Build an Angular component to display the live video stream. The component must prominently display the video feed and ensure it scales responsively on different screen sizes. Acceptance Criteria: The component must display the live stream seamlessly without buffering under standard network conditions. The video player must have start, pause, and mute functionality.", "id": "TASK3" }, { "list": "Develop Angular component for real-time live chat", "acceptance": "Build a chat component in Angular to display chat messages in real-time. The component must include a text input for sending messages and a message display area that auto-scrolls. It must connect to the backend to fetch and send messages. Acceptance Criteria: Messages appear in real-time without delay when sent or received. The chat box must auto-load the latest messages at the start of a stream and notify the user of new messages if they are scrolled away from the latest messages.", "id": "TASK4" }, { "list": "Integrate Angular live video component with Rust streaming service", "acceptance": "Connect the Angular live video component to the video streaming service endpoint implemented in Rust. The Angular frontend must consume the video stream and render it without noticeable delay. Acceptance Criteria: The video stream loads within 2 seconds when the page is accessed and can play for a continuous 10-hour session without stuttering. Errors in stream connection must show an error message dynamically in the UI.", "id": "TASK5" }, { "list": "Integrate Angular live chat component with Rust chat backend service", "acceptance": "Establish connectivity between the Angular chat component and the Rust backend chat service using Websockets or an equivalent real-time communication protocol. Messages sent from the frontend must be properly routed to the backend system, and vice versa. Acceptance Criteria: Chat messages sent by users appear across all active sessions within 200 milliseconds. Chat auto-scroll and input validation (e.g., empty message check) must be functional.", "id": "TASK6" }, { "list": "Ensure synchronization of chat messages with the server", "acceptance": "Implement functionality in the Rust backend chat service to synchronize clients with the latest chat messages from the time the stream began. The Angular frontend should fetch and cache these messages on load. Acceptance Criteria: Joining users receive all previous messages from the current session in chronological order upon entering. The system must ensure no duplicate messages are sent.", "id": "TASK7" }, { "list": "Implement error handling and retry mechanisms for live video and chat", "acceptance": "Add logic in both the Angular frontend and Rust backend to detect and handle network disruptions for the video and chat services. Include retry mechanisms for reconnecting after failures. Acceptance Criteria: If either the video stream or chat connection is interrupted, the UI must display an appropriate message and attempt to reconnect within 5 seconds. If reconnection fails after 3 attempts, a detailed error message must be displayed.", "id": "TASK8" }, { "list": "Test live video and chat functionalities for performance and scalability", "acceptance": "Conduct stress tests for both the video and chat services to ensure they can handle high traffic. Test scenarios should include 100,000 concurrent users accessing the stream and at least 1,000,000 messages per minute on chat. Acceptance Criteria: The services must maintain responsiveness under peak load. Messages and video streams must experience no more than 1 second of delay under these conditions.", "id": "TASK9" } ] }, { "id": "US3", "name": "Facilitate Viewer Interaction and Chat Moderation for Creators", "description": "Ability to interact with viewers and moderate chat during a live stream. In order to respond to viewer queries and maintain a safe environment. As a creator, I want the ability to manage live chat and interact with viewers during my live session. Acceptance Criteria: Creators must see incoming messages in real-time as a chat overlay or in a separate panel. Creators should have the ability to highlight and reply to specific messages directly. An option to remove or block inappropriate messages or users from the chat must be available. The total number of chat participants and messages must be displayed. Creators must receive notifications of flagged messages requiring moderation.", "tasks": [ { "list": "Implement real-time chat streaming functionality on the Rust backend", "acceptance": "Create a Rust module to process and stream chat messages in real-time. Use the specified message structure to handle input (e.g., `message_id`, `user_id`, `content`, `timestamp`). Implement WebSocket functionality to push chat data to the front-end in real-time. Validate payload structure and reject malformed messages. Messages must include the `creator_id` to ensure appropriate delivery. Acceptance Criteria: Real-time streaming of chat messages must function as described. Only valid messages are streamed. Any validation errors must trigger a comprehensive error response to the client.", "id": "TASK1" }, { "list": "Develop a front-end Angular component to display real-time chat messages", "acceptance": "Create an Angular component named `ChatOverlay` to render incoming chat messages. Consume the WebSocket endpoint implemented in TASK1. Ensure proper rendering of `user_id`, `timestamp`, and `content` fields. Add a scrollable UI element to display messages with a fixed viewport size. Test the component to ensure all incoming messages are displayed dynamically without user action. Acceptance Criteria: The `ChatOverlay` must display real-time chat updates as received. The UI must handle up to 1,000 concurrent messages efficiently. Any rendering failure should log errors while continuing to process new messages.", "id": "TASK2" }, { "list": "Enable creators to highlight and reply to specific messages in chat", "acceptance": "Update the `ChatOverlay` Angular component to include a reply and highlight button next to each message. When clicked, the reply option must allow the creator to compose a reply using a reply box. The reply must include the `message_id` and send the composed text to the WebSocket endpoint for processing. Highlighted messages should be visually marked using CSS properties. Acceptance Criteria: Creators can reply to messages, and replies must be correctly sent to the WebSocket endpoint with the requisite `message_id`. Highlighting a message must persist until removed manually. CSS styling of highlighted messages must be clearly visible across devices.", "id": "TASK3" }, { "list": "Add functionality to remove or block inappropriate messages or users", "acceptance": "Update the Rust backend to handle block/remove requests. Implement an API endpoint `/chat/moderation` that accepts `user_id` or `message_id` along with an action (`remove` or `block`) as payload. Removing a message should mark it as deleted in the system and notify active chat sessions immediately via WebSocket. Blocking a user should include their `user_id` in a restricted list and stop processing subsequent messages from this user. Update the Angular component to provide moderation actions in the UI for each message. Acceptance Criteria: Inappropriate messages must be removed immediately upon action. Blocked users' messages must no longer appear in chats. Handle errors (e.g., user/message not found) by returning HTTP 400 with relevant error messaging.", "id": "TASK4" }, { "list": "Display total chat participant count and messages for creators", "acceptance": "Modify the Rust backend to maintain a real-time count of active participants and total messages. Use a Redis cache to track connected WebSocket clients. Extend the WebSocket message payload to include `user_count` and `message_count`. Update the Angular component to display these counts above the chat window. Add tests to verify real-time updates of counts upon participant changes. Acceptance Criteria: The participant count must update accurately as users join or disconnect. The message count must increment correctly with valid messages. Any error or disconnection must not disrupt the counting feature.", "id": "TASK5" }, { "list": "Implement notifications for flagged messages requiring moderation", "acceptance": "Create a keyword-based moderation handler in the Rust backend to flag inappropriate messages. Define a keyword list and match messages against it. If a message matches, mark it as flagged and send a notification via WebSocket to the creator. Extend the Angular component to display flagged message notifications in a separate panel. Test with different flagged message scenarios to verify accurate notification delivery. Acceptance Criteria: Flagged messages must trigger a notification to the creator immediately. Notifications must include `message_id`, `user_id`, and the offending content. Non-matching messages must pass through unaltered.", "id": "TASK6" } ] }, { "id": "US4", "name": "Enable Stream Scheduling and Notifications for Viewers", "description": "Ability to schedule live streams and notify viewers of upcoming sessions. In order to maximize audience participation and engagement. As a creator, I want the ability to schedule live streams and notify my audience in advance. Acceptance Criteria: Creators must be able to schedule a live stream while configuring parameters such as time, title, and description. Once scheduled, a notification must be sent to subscribed viewers using push notifications or emails. Scheduled live streams must appear as upcoming events on the viewer's dashboard. The system should display a countdown timer for scheduled streams. Viewers must receive a reminder notification 10 minutes before the live stream starts.", "tasks": [ { "list": "Implement Creator's Live Stream Scheduling API Endpoint", "acceptance": "Create an API endpoint in Rust enabling creators to schedule live streams. The endpoint should accept input parameters such as 'time' (ISO 8601 format), 'title' (string, max 255 chars), and 'description' (string, max 1000 chars). Validate the input for required fields and data types. Persist the data in a GCP-backed database under a 'scheduled_streams' table. Ensure the response contains a unique stream ID upon success. Return error codes for invalid input or persistence failures. Acceptance Criteria: The API must persist the provided data accurately, return a unique stream ID on success, and produce relevant error codes for validation and system errors.", "id": "TASK1" }, { "list": "Design Frontend Interface for Scheduling Live Streams", "acceptance": "Create a new Angular component for the live stream scheduling form. The form must include inputs for 'time' (datetime picker), 'title' (text input), and 'description' (textarea). Integrate form validations such as required fields, character limits, and correct datetime format. On form submission, call the backend scheduling API and display success or error messages. Acceptance Criteria: The UI form must validate inputs as per backend requirements, submit valid data to the API endpoint, and display appropriate messages based on API response.", "id": "TASK2" }, { "list": "Implement Notification Service for Subscribed Viewers", "acceptance": "Develop a Rust-based notification service that triggers upon successful live stream scheduling. This service must retrieve the list of subscribed viewers from the GCP database and send notifications (push notifications and/or emails) with details of the scheduled live stream (title, time, description). Ensure the service retries failed notifications up to three times. Acceptance Criteria: The service must send notifications to all subscribed viewers, handle error retries, and log failures for non-deliverable notifications.", "id": "TASK3" }, { "list": "Display Scheduled Live Streams on Viewer Dashboard", "acceptance": "Update the Angular 'Viewer Dashboard' UI to fetch and display scheduled live streams from the 'scheduled_streams' table via a new API endpoint. Each stream entry must show the title, time, and description. Include unit tests for rendering and API integration. Acceptance Criteria: Scheduled live streams must appear correctly in the dashboard with accurate data, and API errors should display a fallback error message.", "id": "TASK4" }, { "list": "Implement Countdown Timer for Scheduled Live Streams", "acceptance": "Enhance the 'Viewer Dashboard' UI to include a countdown timer for each scheduled live stream. The timer must display days, hours, minutes, and seconds remaining until the stream starts, updating in real-time. Ensure timers gracefully handle past-due times by displaying 'Event Started'. Acceptance Criteria: Countdown timers must function correctly, updating at appropriate intervals, and handle edge cases such as past-due streams.", "id": "TASK5" }, { "list": "Send Reminder Notification 10 Minutes Before Start", "acceptance": "Create a scheduled job in Rust that runs periodically and identifies live streams starting in the next 10 minutes. For such streams, send reminder notifications (push notifications and emails) to subscribed viewers. Ensure the job runs efficiently and avoids duplicate notifications. Acceptance Criteria: Notifications must be sent 10 minutes before the stream starts, with no duplicate reminders, and failed notifications must be logged.", "id": "TASK6" }, { "list": "Create API Endpoint for Retrieving Upcoming Streams", "acceptance": "Develop a Rust API endpoint to fetch all upcoming streams from the 'scheduled_streams' table, including their title, time, and description. Ensure the API response is optimized for frontend rendering and handles pagination. Return appropriate error codes for database access issues. Acceptance Criteria: The endpoint must return accurate upcoming stream data, support pagination, and handle errors gracefully.", "id": "TASK7" }, { "list": "Unit and Integration Testing for Scheduling Module", "acceptance": "Implement unit tests for the Rust scheduling API and notification logic, as well as integration tests to validate the end-to-end flow (from backend to frontend). Cover test cases for valid and invalid input, database persistence, and notification delivery errors. Acceptance Criteria: All critical paths in the scheduling and notification feature must have test coverage, with tests passing successfully.", "id": "TASK8" } ] }, { "id": "US5", "name": "Ensure High-Quality Live Streaming and Error Handling", "description": "Ability to optimize video streaming quality and handle disconnection issues. In order to provide a smooth and reliable viewing experience. As a user, I want uninterrupted video streaming even under varying network conditions. Acceptance Criteria: The system should dynamically adjust the video quality based on network bandwidth. Viewers should have the ability to manually select video quality options (e.g., 1080p, 720p). Playback must have minimal buffering, with latency maintained below a predefined threshold. Creators must receive a performance indicator showing current bitrate and stream health. In case of disconnection, the system must attempt automatic reconnection and notify both creators and viewers of any delays.", "tasks": [ { "list": "Implement dynamic video quality adjustment based on network bandwidth in Rust backend", "acceptance": "Create a module in Rust to monitor network bandwidth in real-time and adjust video quality accordingly. Implement a function to calculate bitrate thresholds and switch between stream quality (e.g., 1080p, 720p) dynamically. Acceptance Criteria: The module must adjust video quality seamlessly without buffering. The video quality change must occur within 1 second of bandwidth fluctuation. Validations must include bitrate thresholds and network speed metrics.", "id": "TASK1" }, { "list": "Create manual video quality selection functionality in Angular frontend", "acceptance": "Add a dropdown or button-based UI in Angular to allow users to select video quality manually (e.g., 1080p, 720p). Integrate selection inputs with the Rust backend to override dynamic quality adjustment when manually selected. Acceptance Criteria: Users should see the available resolution options. Selected options must immediately take effect, overriding the automatic adjustment until deselected. Validation must ensure available options are based on backend-provided stream data.", "id": "TASK2" }, { "list": "Implement low-latency streaming functionality with buffering minimization", "acceptance": "Optimize the Rust backend streaming module to send minimal buffered data and maintain a latency threshold under predefined limits. Implement efficient codec configurations and buffer management policies. Acceptance Criteria: Ensure playback latency remains below the threshold defined in user story (e.g., 1 second). Playback must continue without noticeable pauses or stalls even under fluctuating network conditions. Validate with simulated network tests.", "id": "TASK3" }, { "list": "Create a performance indicator UI for stream bitrate and health in Angular frontend", "acceptance": "Design and implement a frontend component in Angular to display stream bitrate and health metrics to the creator. Connect this UI to receive live data from the Rust backend. Acceptance Criteria: Metrics displayed must include current bitrate and stream quality health. Refresh the information every 2 seconds. Validate that creators are alerted for bitrate drops below certain thresholds.", "id": "TASK4" }, { "list": "Implement automatic reconnection mechanism in Rust backend for disconnection scenarios", "acceptance": "Create a function in the Rust backend to detect disconnections and attempt reconnection with exponential backoff up to a maximum retry limit. Ensure reconnection attempts are logged. Acceptance Criteria: The function must detect and log all disconnection events. Must attempt automatic reconnection, and retry attempts should not exceed maximum limits. Include validation for successful reconnection in 95% of cases within 5 retries.", "id": "TASK5" }, { "list": "Notify users about disconnection and reconnection attempts via Angular frontend", "acceptance": "Develop a notification system in Angular to inform viewers and creators about disconnection events and ongoing reconnection attempts. Include UI elements showing reconnection status. Acceptance Criteria: Viewers and creators must receive separate notifications for disconnection and reconnection. Notifications must update dynamically with real-time status. Validations should cover edge cases like continuous failed reconnections and final failure alerts.", "id": "TASK6" } ] } ] }