@getollie/cli 0.0.1

package/library/web_applications-communication/user-registration-chat-dynamic-modules.json

@@ -0,0 +1,68 @@
+{
+  "index": 910,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. While ensuring all functionality, integrate and beautify all code, and provide examples of user registration and chat functionality, with example modules placed in the app for dynamic module loading.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the user registration system fully implemented?",
+      "description": "Review whether the code accurately implements user registration functionality including form validation, secure password handling (hashing/salting), and proper error handling. Check if email verification is included, and if the registration flow prevents common security issues (SQL injection, XSS). Score 0 if registration logic is missing, 5 if basic registration exists but with security flaws, and 10 if a complete secure registration system is implemented with proper validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the chat functionality properly implemented?",
+      "description": "Evaluate the chat system implementation, including real-time messaging capabilities, message history persistence, and user presence indicators. Check if the solution uses WebSockets or a similar real-time protocol, handles message formatting/sanitization, and includes typing indicators. Deduct 5 points if messages aren't persistent, 3 points if real-time updates are missing, and 2 points if user presence tracking is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the dynamic module loading system correctly implemented?",
+      "description": "Assess the implementation of dynamic module loading that allows components to be loaded on demand. Check if the code uses modern module loading techniques (e.g., import(), RequireJS, webpack code splitting), handles loading states properly, and includes error recovery for module loading failures. Deduct 5 points if loading states aren't handled, 5 points if error conditions aren't managed gracefully, and 3 points if module dependencies aren't correctly managed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the code integration and beautification executed effectively?",
+      "description": "Review how well the code is integrated across different components and beautified for readability. Evaluate consistent coding style, proper indentation, meaningful variable/function names, and appropriate comments. Check if CSS is organized (using a methodology like BEM, SMACSS, or CSS-in-JS), and if the UI components follow a consistent design language. Deduct 3 points for inconsistent styling, 3 points for poor code organization, and 4 points for inadequate documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as form validation errors, network interruption, authentication failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time user activity indicators 2. Customizable UI themes 3. Message reactions/emojis 4. Interactive notifications). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple authentication flows coexisting) 2. Function modules unrelated to registration or chat (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/business logic/data layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast interactions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "medium"
+}

package/library/web_applications-communication/vue-3-facial-registration-mobile-camera-background.json

@@ -0,0 +1,68 @@
+{
+  "index": 1414,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Vue 3 facial registration calling the mobile phone camera with background image addition.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the facial registration core functionality fully implemented?",
+      "description": "Check if the code correctly implements face detection using appropriate APIs (like Face API JS or OpenCV.js) and captures facial landmarks for registration. The system should detect faces in real-time through the mobile camera feed and validate that a proper face is present before allowing registration. Score 0 if face detection is not implemented, 5 if basic detection without landmarks is implemented, and 10 if full facial feature extraction is properly configured.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the mobile camera access properly implemented?",
+      "description": "Verify that the code uses navigator.mediaDevices.getUserMedia() with proper constraints for mobile devices, handles permissions correctly, and includes fallback mechanisms. Check if the camera selection works for both front and back cameras and adjusts resolution based on device capabilities. Deduct 5 points if permission handling is missing, 3 points if device orientation changes aren't handled, and 2 points if there's no fallback for browsers with limited support.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the background image addition feature correctly implemented?",
+      "description": "Evaluate whether the code properly implements background replacement or addition using either Canvas manipulation, WebGL shaders, or CSS compositing. Check if the system handles edge detection around the face for natural blending and provides options for different backgrounds. Deduct 5 points if the background appears with jagged edges, 3 points if performance issues occur on mobile devices, and 2 points if background customization options are limited.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is proper Vue 3 composition API implementation used?",
+      "description": "Assess whether the code follows Vue 3 best practices using the Composition API with proper reactive references, computed properties, and lifecycle hooks. Check if components are well-structured with clear separation of concerns. Deduct 5 points for using Options API instead of Composition API, 3 points for improper ref/reactive usage, and 5 points for component logic that should be extracted into composables.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as camera permission denied, face not detected, device orientation changes, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time facial expression detection 2. Multiple background filter options with previews 3. Adjustable face enhancement features). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple camera initialization methods) 2. Function modules unrelated to facial registration (e.g., unnecessary animations) 3. Fancy effects that affect performance on mobile devices. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating camera access/face detection/UI components), code reusability through composables, and responsive design principles for mobile. Deduct 5 points if global state is used inappropriately, 5 points if there's no error handling strategy, and 5 points if the code lacks documentation or type definitions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern mobile UI principles: 1) Touch-friendly element sizing (min 44x44px touch targets) 2) Clear visual feedback for registration steps 3) Appropriate use of mobile design patterns (bottom navigation, proper spacing). Deduct 3 points for each UI element that isn't mobile-optimized, 5 points for poor camera framing guidance, and 5 points for illegible text on varied backgrounds. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the application provides smooth performance on mobile devices: 1) Camera feed maintains at least 24fps 2) Face detection overlay renders without jitter 3) Background addition happens with minimal lag. Deduct 5 points for each second of processing delay, 3 points for camera feed stuttering, and 5 points if the facial registration flow requires more than 3 steps to complete. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "hard"
+}

package/library/web_applications-communication/vue-3-tiktok-like-video-app.json

@@ -0,0 +1,68 @@
+{
+  "index": 1299,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Please use Vue 3 to implement an app similar to TikTok, with only 2 video elements to mimic TikTok's infinite scroll effect.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the infinite scroll effect correctly implemented?",
+      "description": "Review whether the code accurately implements the infinite scroll effect using only 2 video elements (preloading/swapping mechanism). Check if videos are properly loaded, played, and swapped as the user scrolls. Score 0 if implementation is missing, 5 if basic scrolling works but has noticeable gaps, and 10 if the infinite scroll is seamless like TikTok's.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the video playback and control system properly implemented?",
+      "description": "Evaluate if videos autoplay when visible, pause when scrolled away, and have proper controls (play/pause, sound on/off). Check if videos preload correctly to avoid buffering during scrolling. Deduct 5 points if videos don't autoplay/pause appropriately, and 3 points if basic controls are missing or non-functional. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the core TikTok-like UI components present?",
+      "description": "Check if essential UI elements are implemented: video feed, like/comment/share buttons, user profile info, caption text. Deduct 2 points for each missing essential component. Give 10 points if all core elements are present and properly positioned according to TikTok's layout standards.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the Vue 3 Composition API utilized effectively?",
+      "description": "Assess whether the implementation leverages Vue 3's Composition API appropriately (ref, reactive, computed, watch, lifecycle hooks). Examine if state management is handled properly for video switching. Deduct 5 points if using primarily Options API instead, and 3 points if reactive state isn't properly managed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common edge cases (network issues, video loading errors, different screen sizes, orientation changes). Code should gracefully handle these situations with appropriate error states or fallbacks. Give 10 points if all major edge cases are handled, 5 points if only some are covered, and 0 points if error handling is absent.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Video transitions/effects 2. Double-tap like animation 3. Video progress bar). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple video loading mechanisms) 2. Function modules unrelated to the TikTok-like experience 3. Fancy effects that affect scrolling performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review component organization (separation of concerns between UI/logic/services), code reusability, and proper Vue best practices. Deduct 5 points if components are monolithic or too coupled; deduct 5 points if there's excessive code duplication; deduct 5 points if Vue reactivity system is misused. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the UI follows TikTok's design language: 1) Dark theme with high contrast 2) Proper spacing of interactive elements (safe touch areas of at least 44×44px) 3) Typography hierarchy (captions vs. usernames vs. counts). Deduct 3 points for each significant deviation from TikTok's visual identity, 5 points for poor contrast affecting readability, and 5 points for overcrowded UI elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the app feels native and responsive: 1) Video switching happens within 100ms of scroll completion 2) UI interactions provide immediate feedback 3) Animations are fluid (60fps) during scrolling and transitions. Deduct 5 points if video switching has noticeable delay, 3 points for janky scrolling, and 5 points if interactive elements have delayed response. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "medium"
+}

package/library/web_applications-communication/vue-ai-conversation-wechat-work-login-spring-boot.json

@@ -0,0 +1,68 @@
+{
+  "index": 1653,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable whenever possible. I need to implement an AI conversation page using Vue, which should support WeChat Work login integration and API requests to a Spring Boot backend. How can this be implemented? Please provide detailed code and explanations.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Vue.js project structure properly organized?",
+      "description": "Evaluate whether the code follows Vue.js best practices with a clear separation of components, views, services, and store modules. Check for proper use of Vue CLI scaffolding, clear folder structure (src/components, src/views, src/services, src/store), and appropriate naming conventions. Score 0 if the structure is chaotic, 5 if basic organization exists, and 10 if it follows industry-standard project architecture with reusable components.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the WeChat Work login integration implemented correctly?",
+      "description": "Review the implementation of WeChat Work SDK integration, including proper OAuth flow, QR code authentication, handling of callback URLs, token storage, and refresh mechanisms. Check for proper error handling during login failures. Deduct 5 points if the login flow is incomplete, 3 points if security best practices are not followed (such as insecure token storage), and 3 points if the integration lacks proper session management. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the AI conversation interface properly implemented?",
+      "description": "Assess whether the conversation UI includes essential features: message history display, input area with submit functionality, loading indicators, and proper message formatting (user vs AI messages). Check for proper handling of conversation state, including message threading and context preservation. Deduct 5 points if the basic chat interface is missing key components, 3 points if message history isn't preserved properly, and 3 points if the UI doesn't clearly distinguish between user and AI messages. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the Spring Boot API integration complete and secure?",
+      "description": "Evaluate the implementation of API services for communicating with the Spring Boot backend, including proper authentication header handling, request/response interceptors, error handling, and retry mechanisms. Check for proper data transformation between frontend and backend. Deduct 5 points for missing authentication, 3 points for inadequate error handling, and 3 points for lack of request cancellation or duplicate request prevention. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as API failures, network interruptions, authentication errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time typing indicators 2. Message read receipts 3. Voice input capability 4. Markdown rendering for AI responses 5. Message reactions). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple HTTP client configurations) 2. Function modules unrelated to the chat application (e.g., unnecessary third-party plugins) 3. Fancy effects that affect performance (e.g., excessive animations or transitions). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI components/API services/state management), proper use of Vue composition API or options API, proper TypeScript usage if applicable, and test coverage. Deduct 5 points if global state pollution is found or Vue best practices are not followed; deduct 3 points if the code duplication rate is high; deduct 3 points if there are no unit tests. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast scrolling through chat history, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "medium"
+}

package/library/web_applications-communication/vue-chat-conversation-list.json

@@ -0,0 +1,68 @@
+{
+  "index": 1707,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration purposes. Write a Vue component that shows a conversation list on the left side, and when a specific conversation is clicked, it displays the chat history on the right side.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Vue component structure properly implemented?",
+      "description": "Evaluate if the code follows Vue best practices with proper component organization. Check for appropriate use of Vue 3 composition API or Vue 2 options API, single-file component structure, and proper separation of template, script, and style sections. Verify if props, emits, and component registration are correctly implemented. Score 0 if the Vue component structure is missing or completely incorrect, 5 if basic structure exists but with significant issues, and 10 if fully compliant with Vue best practices.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the conversation list functionality fully implemented?",
+      "description": "Review whether the left side conversation list displays all conversations with proper styling and interactive elements. Check if each conversation item shows relevant information (e.g., contact name, preview text, timestamp). Verify if the active/selected conversation is visually distinguished. Deduct 3 points if sorting/filtering options are missing, 3 points if conversation previews are incomplete, and 4 points if there's no visual indication of unread or important messages. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the chat history display functionality properly implemented?",
+      "description": "Check if the right side displays the complete chat history for the selected conversation. Verify if messages are properly formatted with sender information, timestamps, and correct visual styling to distinguish between sent and received messages. Evaluate if messages are displayed in the correct chronological order with appropriate spacing. Deduct 3 points if message timestamps are missing, 3 points if there's no visual distinction between sent/received messages, and 4 points if media attachments aren't handled. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the interaction between conversation selection and chat display properly implemented?",
+      "description": "Evaluate if clicking a conversation in the list properly updates the chat display on the right. Check if the state management for the active conversation is implemented correctly, whether using Vuex/Pinia or component state. Verify if there's appropriate loading state management when switching between conversations. Deduct 5 points if clicking doesn't update the display or has significant delay, 3 points if there's no visual feedback on selection, and 2 points if the state persistence between renders is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common edge cases (such as empty conversation list, empty chat history, long messages, different screen sizes, etc.) and provides appropriate error handling or placeholder states. Check for input validation and proper defensive programming. Deduct 3 points for each unhandled edge case, and give 10 points if all common scenarios are properly handled with graceful degradation. If the robustness is average, give 5 points, and if no edge cases are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Message search functionality 2. Typing indicators 3. Read receipts 4. Message reactions 5. Dark/light theme toggle). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant state management (e.g., duplicate conversation tracking) 2. Function modules unrelated to the chat interface (e.g., built-in games or unnecessary toolbars) 3. Overly complex implementations that could be simplified. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review component composition (proper use of child components), state management implementation, code reusability, and naming conventions. Check if the code follows Vue style guide recommendations. Deduct 3 points if global state is used inappropriately, 3 points if component responsibilities are not properly separated, 2 points if naming conventions are inconsistent, and 2 points if there's significant code duplication. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern messaging app conventions: 1) Consistent color scheme with proper contrast 2) Proper layout spacing between conversations and messages 3) Professional typography with readable font sizes. Assess if the conversation list has appropriate width relative to the chat display. Deduct 3 points for poor use of space, 3 points for inconsistent styling between list and chat, 2 points for poor typography, and 2 points for non-responsive design. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the interactions follow best practices: 1) Immediate visual feedback when selecting conversations 2) Smooth transitions when switching between chats 3) Proper scroll behavior in conversation list and chat history (especially for long conversations). Deduct 3 points for lack of loading states, 3 points for jerky transitions, 2 points for scroll issues with long content, and 2 points for poor keyboard navigation support. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "easy"
+}

package/library/web_applications-communication/vue-continuous-log-query-sse-output.json

@@ -0,0 +1,68 @@
+{
+  "index": 1140,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration purposes. Implement a scenario using Vue framework for continuous log query output via SSE (Server-Sent Events).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the SSE connection implementation complete?",
+      "description": "Check if the code properly establishes an EventSource connection to the server endpoint, includes appropriate error handling, reconnection logic, and event listeners. Deduct 5 points if reconnection is not implemented, 3 points if event type filtering is missing. Give 0 points if SSE implementation is absent, 5 points for basic connection, and 10 points for robust implementation with all recommended patterns.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the log data rendering component properly implemented?",
+      "description": "Evaluate whether the Vue component correctly renders streaming log data with virtual scrolling for performance optimization when handling large volumes. Check if logs are properly formatted with timestamps, log levels, and message content. Deduct 3 points if logs aren't visually distinguished by severity level, 5 points if the component doesn't handle large log volumes efficiently. Full score requires proper data binding, reactivity, and optimized rendering.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are filtering and search capabilities implemented for logs?",
+      "description": "Assess if the implementation includes log filtering by severity level, timestamp range, and text search functionality. Check if filters are applied reactively without interrupting the SSE connection. Deduct 3 points for each missing core filter type (severity, time, text search), 5 points if filtering disrupts the SSE connection. Full marks require debounced search, highlighted matches, and preserved filter state.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper handling of SSE connection states and error scenarios?",
+      "description": "Review if the code handles all SSE connection states (connecting, open, error, closed) with appropriate UI feedback. Check for graceful handling of server disconnections, network failures, and reconnection attempts with exponential backoff. Deduct 5 points if error states aren't communicated to users, 3 points if reconnection doesn't use backoff strategy. Full score requires comprehensive state management and user notifications.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as server errors, malformed log entries, network interruption, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time log statistics/analytics 2. Log export functionality 3. Collapsible log grouping 4. Dark/light theme toggle 5. Customizable log highlighting). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple filtering mechanisms) 2. Function modules unrelated to log viewing (e.g., unnecessary dashboards) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review Vue component architecture (SFC structure, proper use of props/emits), state management approach, code reusability, and adherence to Vue best practices. Deduct 5 points if global state is mismanaged; deduct 3 points if component responsibilities are poorly separated; deduct 3 points if Vue lifecycle hooks are misused; deduct 3 points if modern Vue features (composition API, script setup) are not utilized appropriately. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the log viewer UI follows professional design principles: 1) Consistent color coding for log levels 2) Proper layout with adequate whitespace 3) Typography that enhances readability (monospace for log content, sufficient contrast). Deduct 3 points for poor log level visualization, 5 points for cluttered layout, and 5 points for hard-to-read text formatting. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the log viewer provides smooth user experience: 1) New logs appear without UI jank 2) Applying filters responds in under 200ms 3) Scrolling through large log volumes remains smooth 4) Visual indicators for new logs arriving. Deduct 5 points if the UI freezes during log influx, 3 points for laggy filtering, and 5 points if the current position is lost when new logs arrive. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "medium"
+}

package/library/web_applications-communication/vue-deepseek-api-streaming-text-display.json

@@ -0,0 +1,68 @@
+{
+  "index": 1155,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Write me code for implementing a streaming text display using Vue + Axios + ThinkPHP with the Deepseek API.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the streaming text display core functionality fully implemented?",
+      "description": "Review whether the code accurately implements real-time streaming text display through Vue.js reactive data binding, including proper handling of Server-Sent Events (SSE) or chunked transfer encoding. Check if text chunks are progressively rendered with smooth character-by-character or word-by-word animation effects. Score 0 if streaming display is not implemented, 5 if only basic text appending is shown, and 10 if smooth streaming with proper buffering and display control is fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Vue + Axios integration properly architected?",
+      "description": "Evaluate whether Axios is correctly configured for streaming requests with proper responseType settings (stream/text), timeout handling, and progress monitoring. Check if Vue's reactive system is properly utilized for real-time UI updates without performance bottlenecks. Deduct 5 points if request cancellation is not implemented, and 3 points if memory leaks occur during long streaming sessions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the ThinkPHP backend streaming response correctly implemented?",
+      "description": "Check whether the ThinkPHP backend properly implements streaming response with correct headers (Transfer-Encoding: chunked or Content-Type: text/event-stream), handles Deepseek API integration with proper error handling and rate limiting. Verify if the backend maintains persistent connections and implements proper buffer flushing. Deduct 5 points if API key security is not handled, and 3 points if streaming connection drops are not managed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the Deepseek API integration robust and complete?",
+      "description": "Evaluate whether the Deepseek API integration includes proper authentication, request formatting, response parsing, and error handling for various API response scenarios. Check if streaming parameters are correctly configured and if API rate limits and quotas are properly managed. Deduct 5 points if API response validation is missing, and 3 points if retry mechanisms for failed requests are not implemented. Give 10 points if fully implemented with comprehensive error recovery.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruption, API timeouts, malformed responses, component unmounting during streaming, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle these edge cases and provide graceful degradation, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the streaming experience (e.g., 1. Real-time typing sound effects synchronized with text appearance 2. Customizable streaming speed controls 3. Text highlighting with different colors for different content types 4. Export functionality for streamed content 5. Pause/resume streaming capabilities). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple text rendering methods coexisting) 2. Function modules unrelated to streaming text display (e.g., built-in file management system) 3. Fancy effects that affect streaming performance (e.g., complex particle animations during text rendering). Deduct 3 points for each redundancy found, and directly deduct 10 points if core streaming functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating API service/Vue components/utility functions), proper Vue composition API or options API usage, and TypeScript integration if applicable. Deduct 5 points if global state pollution is found or Vue best practices are not followed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if proper component lifecycle management is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the streaming text display follows modern design principles: 1) Harmonious color matching with proper contrast for readability 2) Proper typography with adequate line spacing (1.4-1.6x) and font sizing 3) Clean layout with appropriate whitespace and visual hierarchy 4) Loading states and progress indicators. Deduct 3 points for each poorly designed visual element, 5 points for poor text readability, and 5 points for chaotic layout during streaming. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the streaming animation smooth and seamless?",
+      "description": "Judge whether the streaming text animation conforms to human reading patterns: 1) Consistent streaming speed without jarring stops 2) Smooth cursor or typing indicator animations 3) Proper text wrapping and overflow handling 4) No visual glitches during rapid text updates 5) Responsive design that works across different screen sizes. Deduct 5 points for each choppy animation, 3 points for text rendering artifacts, and 5 points for poor mobile streaming experience. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "hard"
+}

package/library/web_applications-communication/vue-login-homepage-with-users-table.json

@@ -0,0 +1,68 @@
+{
+  "index": 747,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable whenever possible. -- Create a users table\nCREATE TABLE IF NOT EXISTS users (\n    id BIGINT AUTO_INCREMENT PRIMARY KEY,\n    username VARCHAR(50) NOT NULL UNIQUE,\n    password VARCHAR(255) NOT NULL,\n    role_id TINYINT NOT NULL COMMENT '1 represents admin, 2 represents regular user'\n) COMMENT 'User table, used to store user information';\n\nPlease create a login page and a home page in Vue based on the users table above.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Vue user authentication system properly implemented?",
+      "description": "Check if the login functionality correctly validates credentials against the users table, implements proper session/token management, and handles authentication errors. Score 0 if authentication is missing, 5 if basic authentication exists but lacks security features, and 10 if it includes token refresh mechanisms, session timeout, and proper security measures.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is role-based access control (RBAC) implemented correctly?",
+      "description": "Verify that the application distinguishes between admin (role_id=1) and regular users (role_id=2), showing different UI elements and granting appropriate permissions based on roles. Deduct 5 points if roles are not implemented, 3 points if role checks exist but can be bypassed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the login page implementation complete and secure?",
+      "description": "Evaluate whether the login page includes input validation, secure password handling (no client-side plaintext), visual feedback for validation errors, and protection against brute force attacks. Check for CSRF token implementation. Deduct 3 points for each missing security feature. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the home page implementation functional and role-appropriate?",
+      "description": "Examine whether the home page displays content appropriate to the user's role, includes a proper logout mechanism, and handles unauthorized access attempts. Check if the navigation reflects available permissions. Deduct 3 points if role-specific content is missing, 3 points for missing logout functionality, and 4 points if unauthorized access handling is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid credentials, network failures, session expiration, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Two-factor authentication 2. Remember me functionality 3. Login history tracking). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple authentication methods unnecessarily implemented) 2. Function modules unrelated to user authentication (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., heavy animations during login). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating API calls/state management/UI components), code reusability, and Vue best practices. Deduct 5 points if global state is mismanaged; deduct 5 points if the code contains significant duplication; deduct 5 points if Vue component design principles are violated (e.g., mixing concerns). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional form design (consistent input sizes, clear labels). Deduct 3 points for poor form alignment, 5 points for inconsistent styling between pages, and 5 points for accessibility issues (poor contrast, missing labels). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Login button shows loading state during authentication 2) Form validation provides real-time feedback 3) Transitions between login and home page are smooth. Deduct 5 points for lack of loading indicators, 3 points for jarring page transitions, and 5 points for delayed feedback on form submissions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "easy"
+}