@getollie/cli 0.0.1

package/library/web_applications-communication/react-autocomplete-text-box-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 264,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration purposes. React implementation: Create an autocomplete text box",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the autocomplete core functionality fully implemented?",
+      "description": "Review whether the React component accurately implements real-time search filtering, keyboard navigation (up/down arrows, Enter to select, Escape to close), and click selection. The component should handle input changes with proper debouncing (200-300ms) and display filtered results dynamically. Score 0 if basic autocomplete logic is missing, 5 if only basic filtering works, and 10 if all core interactions including keyboard navigation are fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the data handling and performance optimization properly implemented?",
+      "description": "Check whether the implementation includes efficient data filtering algorithms, proper use of React hooks (useState, useEffect, useMemo), and performance optimizations like debouncing/throttling for API calls. Evaluate if large datasets are handled efficiently without UI blocking. Deduct 5 points if no debouncing is implemented, 3 points if unnecessary re-renders occur, and 2 points if filtering algorithm is inefficient. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the component state management and lifecycle properly designed?",
+      "description": "Evaluate whether the React component properly manages internal state (input value, dropdown visibility, selected index, filtered options) and handles component lifecycle events correctly. Check for proper cleanup of event listeners and timers. The component should handle edge cases like empty results, loading states, and error handling. Deduct 5 points if state management is chaotic, 3 points if memory leaks exist due to improper cleanup. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the component accessibility and usability standards compliant?",
+      "description": "Check whether the autocomplete component implements proper ARIA attributes (aria-expanded, aria-activedescendant, role='combobox'), supports screen readers, and follows accessibility guidelines. The component should be keyboard-navigable and provide clear focus indicators. Deduct 5 points if ARIA attributes are missing, 3 points if keyboard navigation is incomplete, and 2 points if focus management is poor. Give 10 points if fully accessible.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as empty input, special characters, network failures for async data, rapid typing, component unmounting during async operations) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle these edge cases, 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 experience (e.g., 1. Highlighting matched text portions 2. Recent searches memory 3. Category grouping of results 4. Custom result templates 5. Multi-select capability). 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 filtering logics coexisting) 2. Function modules unrelated to autocomplete (e.g., built-in form validation) 3. Fancy effects that affect performance (e.g., complex animations on every keystroke). Deduct 3 points for each redundancy found, and directly deduct 10 points if core autocomplete functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review React component structure (proper component composition, custom hooks usage, props interface design), TypeScript integration if applicable, and code organization. Deduct 5 points if component is not properly decomposed or design patterns are not used; deduct 5 points if code duplication rate is too high (over 30%); deduct 3 points if props are not properly typed or documented. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the autocomplete design follows modern UI principles: 1) Harmonious color matching with proper contrast ratios 2) Consistent spacing and alignment (following 8px grid system) 3) Professional typography (readable font sizes ≥ 14px, proper line heights) 4) Clear visual hierarchy between input and dropdown. Deduct 3 points for each crowded visual element, 5 points for poor color contrast, and 5 points for inconsistent styling. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the autocomplete interactions conform to user expectations: 1) Instant visual feedback on input changes 2) Smooth dropdown animations (200-300ms duration) 3) Clear hover and focus states 4) Responsive selection feedback. Deduct 5 points for each interaction without proper feedback, 3 points for jarring animations or layout shifts, and 5 points if dropdown positioning is inconsistent or cuts off. Full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "easy"
+}

package/library/web_applications-communication/react-native-flashlist-chat-application.json

@@ -0,0 +1,68 @@
+{
+  "index": 952,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the code you generate is executable and demonstrable. React Native FlashList for chat application.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the FlashList implementation optimized for chat performance?",
+      "description": "Review whether the code properly implements FlashList with optimized rendering for chat messages, including virtualization settings (estimatedItemSize, overrideItemLayout), proper key extraction, and message rendering optimization. Check for memory leak prevention with useCallback for handlers and memoization of item renderers. Score 0 if basic FlashList is not implemented, 5 if implemented with default settings, and 10 if fully optimized with performance considerations.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are chat-specific UI components properly implemented?",
+      "description": "Evaluate whether the code includes essential chat UI components such as message bubbles with proper styling for sent/received messages, timestamps, read receipts, user avatars, and media previews. Check for proper text overflow handling, emoji support, and URL detection/preview. Deduct 3 points if message types aren't differentiated, 3 points if timestamps/read receipts are missing, and 4 points if media handling is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the message loading and pagination mechanism effectively implemented?",
+      "description": "Check whether the code implements efficient pagination with onEndReached handler, proper loading states, and scroll position maintenance when new messages are added or history is loaded. Verify implementation of bi-directional loading (newer messages at bottom, older at top). Deduct 5 points if pagination is not implemented, 3 points for missing loading indicators, and 3 points if scroll position jumps during new message arrival. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are chat-specific interactions and animations properly handled?",
+      "description": "Assess whether the code includes smooth scrolling to bottom, typing indicators, pull-to-refresh functionality, and appropriate animations for new messages. Check for message action handlers (long press for options), swipe actions, and reply-to functionality. Deduct 3 points for each missing core interaction, and award full 10 points only if animations are performant (verified using Flipper or performance metrics).",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as empty message lists, network failures, malformed message data, extremely long messages, etc.) and provide friendly error handling 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. Message reactions with animations 2. Voice message visualization 3. Contextual smart replies 4. In-chat media gallery). 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 re-renders causing performance issues 2. Unnecessary wrapper components adding to the component tree 3. Heavy animations or effects that affect scrolling performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core messaging functionality is compromised by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating message rendering/state management/network layers), component reusability, and appropriate use of React hooks. Deduct 5 points if prop drilling is excessive instead of using Context; deduct 5 points if components have mixed responsibilities; deduct 5 points if there's no error boundary implementation. 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 chat UI principles: 1) Clear visual distinction between sent and received messages 2) Proper whitespace around messages (following 8px principle) 3) Readable typography (minimum 14px, contrast ratio ≥4.5:1). Deduct 3 points for each accessibility issue, 5 points for inconsistent bubble styling, and 5 points for poor information hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the chat interactions conform to user expectations: 1) Message send feedback ≤ 100ms 2) Smooth scroll performance (60fps) 3) Keyboard appearance doesn't disrupt visible messages. Deduct 5 points for frame drops during scrolling, 3 points for layout shifts when keyboard appears/disappears, and 5 points for input field that doesn't adjust properly with keyboard. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "hard"
+}

package/library/web_applications-communication/react-tailwind-homepage-development.json

@@ -0,0 +1,68 @@
+{
+  "index": 782,
+  "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. Help me develop a homepage using React 18+ and Tailwind CSS.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the React 18+ project setup correctly implemented?",
+      "description": "Evaluate if the code sets up a proper React 18+ project with necessary dependencies, configuration files (package.json, tsconfig.json if TypeScript), and appropriate folder structure. Check if React 18 specific features like createRoot are properly utilized instead of legacy ReactDOM.render. Score 0 if React 18+ is not used, 5 points if basic setup exists but lacks proper configuration, 10 points for a complete and well-structured React 18+ project setup.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is Tailwind CSS properly integrated and effectively utilized?",
+      "description": "Verify that Tailwind CSS is correctly installed and configured (tailwind.config.js present with proper settings). Check if the code leverages Tailwind's utility classes appropriately instead of custom CSS, uses responsive design classes (sm:, md:, lg:, etc.), and follows Tailwind best practices. Deduct 5 points if Tailwind is installed but barely used, 3 points if configuration is incomplete, and 2 points if utility classes are used inconsistently. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are homepage components properly structured and organized?",
+      "description": "Assess if the homepage is broken down into logical, reusable components (header, navigation, hero section, features, footer, etc.). Check if components follow single responsibility principle and have clear props interfaces. Deduct 3 points for monolithic components, 3 points for prop drilling issues, and 4 points if components are not properly structured or reusable. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the homepage responsive across different device sizes?",
+      "description": "Evaluate if the homepage renders correctly on mobile, tablet, and desktop screens using Tailwind's responsive utilities. Check for appropriate use of flex/grid layouts, proper image handling, and text scaling. Deduct 5 points if the layout breaks on mobile devices, 3 points if tablet view has significant issues, and 2 points for minor responsive problems. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common edge cases (missing data, loading states, error handling, etc.) and provides appropriate fallbacks. Check for proper form validation if forms exist, and handling of asynchronous operations. Code with strong robustness should effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no error handling or loading states exist, 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. Skeleton loading screens 2. Subtle micro-interactions 3. Dark/light mode toggle 4. Animated page transitions). 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. Duplicate component implementations that serve similar purposes 2. Unnecessary third-party libraries for tasks that could be accomplished with React/Tailwind 3. Overengineered solutions for simple problems. Deduct 3 points for each redundancy found, and directly deduct 10 points if core functionality is compromised by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review code organization (proper file/folder structure), component reusability, clean code practices, and performance optimizations (like React.memo, useMemo, useCallback). Deduct 3 points for global state mismanagement, 3 points for excessive re-renders, 2 points for inconsistent naming conventions, and 2 points for lack of code splitting where appropriate. 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 web design principles: 1) Consistent color scheme aligned with Tailwind's color palette 2) Proper spacing using Tailwind's spacing utilities 3) Typography hierarchy with appropriate font sizes and weights 4) Visual hierarchy guiding user attention. Deduct 3 points for inconsistent styling, 3 points for poor contrast or accessibility issues, and 4 points for cluttered layouts or unbalanced visual elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether interactive elements provide appropriate feedback: 1) Hover/focus states for clickable elements 2) Smooth transitions for state changes 3) Loading indicators for asynchronous operations 4) Appropriate animations that enhance UX without being distracting. Deduct 3 points for missing interaction states, 3 points for jarring transitions, and 4 points for confusing navigation patterns or interaction flows. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "easy"
+}

package/library/web_applications-communication/real-time-captioning-mobile-app-ui-design.json

@@ -0,0 +1,68 @@
+{
+  "index": 221,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable for demonstration. Below is a complete UI design solution for a real-time captioning mobile app, including core functional pages and visual style specifications:\n\n1. Design Style\nColor scheme:\n- Primary color: Deep blue (#2563EB) for tech feel + Light gray (#F5F5F5) for background\n- Secondary colors: Green (#10B981) for real-time caption highlights + Red (#EF4444) for recording warnings\nTypography: Google Sans (tech-oriented sans-serif font)\nIcons: Material Design linear icon library\nAnimation effects: Caption line-by-line scrolling, microphone sound wave animation\n\n2. Core Page Designs\n① Splash Screen\nClean LOGO + Slogan (\"Real-time transcription, communication without barriers\")\nDeep blue background + White dynamic waveform graphic\n\n② Main Page (Real-time Captions)\nMain page illustration\n\nHeader bar: Microphone status icon (dynamic sound wave), Language switch button (Chinese/English)\nCentral area:\n- Real-time caption display box (black background with white text, enlarged font)\n- Caption pause/save button (floating in bottom right corner)\nBottom control bar:\n- Large circular microphone button (red/green status toggle)\n- Settings/History record quick access\n\n③ Settings Page\nLanguage settings:\n- Source language/target language selection (dialect options supported)\n- Translation toggle (Chinese-English bidirectional)\nDisplay settings:\n- Caption font size/color\n- Background opacity adjustment\nAdvanced features:\n- Offline mode toggle\n- Sensitive word filtering\n\n④ History Records Page\nTimeline list (grouped by date)\nEach record displays:\n- Timestamp + first line text preview\n- Category tags (meeting/classroom/video, etc.)\nSearch bar + Batch export button (supports TXT/PDF)\n\n⑤ Recording Details Page\nAudio waveform visualization\nFull text display (editable for corrections)\nBottom action bar:\n- Share/Export/Delete\n- Key segment marking feature\n\n⑥ User Onboarding (First Launch)\n3-screen sliding guide:\n- Permission explanations (microphone/storage)\n- Core feature demonstrations (GIF animations)\n- Personalized setting recommendations\n\n3. Interaction Details\nVoice feedback: Vibration notifications when recording starts/ends\nReal-time optimization:\n- Captions scroll line by line (keeping the last 3 lines)\n- Key terminology highlighting (requires custom glossary)\nAccessibility design:\n- High contrast mode\n- Font scaling up to 200%\n\nPlease output the corresponding complete HTML code for me",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Are all core UI pages completely implemented according to the design specifications?",
+      "description": "Review whether the code accurately implements all 6 specified pages (Splash Screen, Main Page, Settings, History Records, Recording Details, User Onboarding) with HTML structure matching the design requirements. Check if each page contains the specified elements: splash screen with logo and slogan, main page with header bar/caption display/control bar, settings with language/display/advanced options, history with timeline list, recording details with waveform visualization, and onboarding with 3-screen guide. Score 0 if missing core pages, 5 if only basic structure is implemented, and 10 if all pages are fully detailed according to specifications.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the visual design strictly follow the specified color scheme and typography standards?",
+      "description": "Evaluate whether the implementation uses the exact color palette: Primary deep blue (#2563EB), light gray background (#F5F5F5), green highlights (#10B981), red warnings (#EF4444). Check if Google Sans font family is properly implemented and Material Design icons are correctly integrated. Verify background opacity settings, high contrast mode availability, and font scaling up to 200% as specified. Deduct 3 points for each incorrect color usage, 5 points if font family is not Google Sans, and 3 points if Material Design icons are missing. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the real-time captioning interface and interaction mechanisms properly implemented?",
+      "description": "Check whether the main captioning interface includes: black background caption display box with white enlarged text, line-by-line scrolling animation keeping last 3 lines visible, dynamic microphone sound wave animation, floating pause/save button, large circular microphone button with red/green status toggle, and key terminology highlighting functionality. Verify if the interface supports the specified real-time optimization features and maintains proper visual hierarchy. Score 0 if core captioning interface is missing, 5 if basic display is implemented without animations, and 10 if all real-time features are fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the specialized features and accessibility options comprehensively developed?",
+      "description": "Evaluate implementation of advanced features: language switching (Chinese/English with dialect support), translation toggle, offline mode, sensitive word filtering, audio waveform visualization, editable text corrections, category tagging system, search functionality, batch export (TXT/PDF), key segment marking, vibration feedback, and permission handling explanations. Check if accessibility features like high contrast mode and 200% font scaling are working. Deduct 3 points for each missing major feature, 5 points if accessibility options are not implemented. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust and handles edge cases appropriately?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as microphone permission denial, network interruption, audio processing errors, invalid user inputs, page navigation failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include proper error boundaries, fallback mechanisms, and user-friendly error messages. Give 10 points if fully robust, 5 points if average robustness, and 0 points if no exception handling is present.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there innovative features that enhance user experience beyond basic requirements?",
+      "description": "Check whether the code includes surprise features that enhance the captioning experience (e.g., 1. Smart punctuation insertion 2. Speaker identification and labeling 3. Custom vocabulary learning 4. Voice command shortcuts 5. Real-time confidence scoring display 6. Automatic meeting minutes generation). Add 3 points for each practical innovative feature implemented that genuinely improves the real-time captioning workflow (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features that detract from the core functionality?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple audio processing pipelines coexisting) 2. Function modules unrelated to real-time captioning (e.g., built-in games or social features) 3. Excessive visual effects that impact performance (e.g., complex 3D animations during captioning). Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code interferes with core captioning performance or usability.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code demonstrate high engineering quality and maintainability?",
+      "description": "Review modular design (such as separating audio processing/UI components/data management layers), component reusability, proper state management, and code organization. Deduct 5 points if global state pollution is found or modern development patterns are not used; deduct 5 points if code duplication rate is too high (over 30%); deduct 3 points if CSS/JavaScript is not properly organized into modules. Evaluate proper use of semantic HTML and accessibility attributes. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional mobile app design standards?",
+      "description": "Evaluate whether the overall design follows modern mobile design principles: 1) Proper color contrast ratios (WCAG AA compliance) 2) Touch-friendly element sizing (minimum 44px touch targets) 3) Consistent spacing system (8px grid adherence) 4) Professional typography hierarchy (readable font sizes ≥14px, proper line heights) 5) Proper visual feedback for all interactive elements. Deduct 3 points for each accessibility violation, 5 points for poor color contrast, and 5 points for inconsistent spacing or typography. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are the animations and transitions smooth with appropriate timing and performance?",
+      "description": "Judge whether the dynamic effects enhance usability: 1) Caption scrolling animations are smooth and don't interfere with reading 2) Microphone sound wave animation reflects actual audio input 3) Page transitions are fluid (300-500ms duration) 4) Touch feedback is immediate (≤100ms) 5) Loading states are properly animated 6) No janky animations or performance issues during real-time captioning. Deduct 5 points for each choppy animation, 3 points for inappropriate timing, and 5 points if animations negatively impact core functionality performance. Full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "hard"
+}

package/library/web_applications-communication/responsive-html-webpage-with-tree-navigation.json

@@ -0,0 +1,68 @@
+{
+  "index": 1815,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for display. Please build a responsive HTML webpage index.html for me with the following requirements: Simplified Chinese language, UTF-8 encoding; tree-like navigation with unlimited levels; includes title and paragraphs; contains images and videos; has a contact form (webmail is sufficient); footer with copyright section. Thank you very much!",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the tree-like navigation with unlimited levels fully implemented?",
+      "description": "Review whether the code accurately implements a multi-level tree navigation structure through HTML/CSS/JavaScript, including expandable/collapsible functionality, proper nesting hierarchy, and smooth navigation transitions. Check if the navigation supports unlimited depth levels with proper indentation and visual hierarchy indicators. Score 0 if only flat navigation is provided, 5 if basic 2-3 level navigation is implemented, and 10 if true unlimited level tree navigation with full interactive features is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the responsive design implementation comprehensive?",
+      "description": "Evaluate whether the webpage implements proper responsive design using CSS media queries, flexible grid systems, and adaptive components. Check breakpoints for mobile (≤768px), tablet (769px-1024px), and desktop (≥1025px) devices. The tree navigation should collapse to mobile-friendly format, images/videos should scale appropriately, and the contact form should remain usable across all devices. Deduct 5 points if navigation breaks on mobile, 3 points if media elements don't scale properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the multimedia elements (images and videos) properly integrated and optimized?",
+      "description": "Check whether images and videos are properly embedded with appropriate formats, alt attributes, and responsive scaling. Evaluate loading optimization techniques such as lazy loading, proper aspect ratio maintenance, and fallback mechanisms. Videos should have controls, proper encoding, and mobile compatibility. Deduct 5 points if images lack alt attributes or proper scaling, 3 points if videos don't work on mobile devices, and 2 points if no loading optimization is implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the contact form functional and properly validated?",
+      "description": "Assess whether the contact form includes proper field validation (email format, required fields), appropriate input types, and user feedback mechanisms. The form should handle submission gracefully with proper error messages and success notifications. Check for accessibility features like proper labels and ARIA attributes. Deduct 5 points if validation is missing or incomplete, 3 points if accessibility features are absent, and 2 points if form submission handling is not implemented. 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 broken image links, failed video loading, form submission errors, navigation overflow, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases like extremely deep navigation levels, long content text, and various screen sizes. Give 10 points if fully robust, 5 points if average robustness, and 0 points if no exception handling is present.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance user experience (e.g., 1. Smooth scroll navigation with section highlighting 2. Search functionality within the tree navigation 3. Breadcrumb trail for deep navigation 4. Dark/light theme toggle 5. Progressive web app features). Add 2-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 navigation systems coexisting) 2. Function modules unrelated to the webpage purpose (e.g., built-in games or unnecessary widgets) 3. Excessive animations that affect performance or usability. Deduct 3 points for each redundancy found, and directly deduct 10 points if core navigation or content display functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review code organization (separation of HTML structure, CSS styling, and JavaScript functionality), semantic HTML usage, and maintainable code structure. Check for proper commenting, consistent naming conventions, and modular CSS/JS organization. Deduct 5 points if inline styles are extensively used instead of external CSS; deduct 5 points if JavaScript is not properly organized or lacks comments; deduct 3 points if HTML semantic elements are not utilized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional visual standards?",
+      "description": "Evaluate whether the overall design follows modern web design principles: 1) Harmonious color scheme with proper contrast ratios (WCAG AA compliance) 2) Consistent typography hierarchy with readable font sizes (≥16px for body text) 3) Proper whitespace and visual breathing room 4) Professional layout with clear visual hierarchy. Deduct 3 points for each visual inconsistency, 5 points for poor color contrast or readability issues, and 5 points for cluttered or unprofessional layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the user interaction smooth and intuitive?",
+      "description": "Judge whether interactive elements provide appropriate feedback and follow UX best practices: 1) Navigation hover/focus states with clear visual feedback 2) Tree navigation expand/collapse animations ≤ 300ms 3) Form field focus states and validation feedback 4) Smooth scrolling and page transitions 5) Clear visual indicators for clickable elements. Deduct 5 points for each interaction without proper feedback, 3 points for slow or jarring animations, and 5 points for unclear interactive elements. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "easy"
+}

package/library/web_applications-communication/robot-dialogue-stream-printing-uniapp-mini-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 1347,
+  "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 for demonstration purposes. Implement a robot dialogue stream printing effect in a uniapp mini-program.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Stream printing implementation completeness",
+      "description": "Evaluate whether the code accurately implements a character-by-character streaming effect for robot dialogue. Check if it includes typing speed control, cursor blinking effect, and proper text rendering. Score 0 if the stream printing effect is not implemented at all, 5 if only basic character-by-character printing is present, and 10 if it includes advanced features like variable typing speed based on content or punctuation pauses.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Uni-app compatibility and framework usage",
+      "description": "Check whether the implementation correctly uses uni-app APIs and follows uni-app development standards. Verify if the code utilizes proper uni-app components (like <view>, <text>), lifecycle hooks, and properly handles cross-platform compatibility issues. Deduct 3 points if platform-specific code is not properly conditioned, 3 points if non-standard HTML/CSS is used instead of uni-app components, and 5 points if the implementation doesn't follow uni-app's reactivity system. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "User interaction and control mechanisms",
+      "description": "Assess whether the implementation provides user control mechanisms like pause/resume, speed adjustment, or skip to end functionality. Check if these controls are accessible and intuitive. Deduct 3 points if pause/resume is missing, 3 points if speed control is absent, and 4 points if there's no way to skip to the end of the dialogue. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Animation smoothness and performance optimization",
+      "description": "Evaluate the performance of the streaming effect. Check for frame drops, memory usage optimization, and whether requestAnimationFrame or similar techniques are used instead of simple setTimeout. Examine if long texts are properly handled without causing UI freezes. Deduct 5 points for noticeable lag on typical devices, 3 points for inefficient rendering approach, and 5 points for memory leaks in animation loops. 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 very long texts, rapid user interactions, component unmounting during animation, empty responses) 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. Dynamic text highlighting 2. Sound effects synchronized with text appearance 3. Animated emoji/icon insertion in streaming text 4. Theme customization for dialogue bubbles). 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 animation functions 2. Function modules unrelated to dialogue streaming (e.g., unnecessary third-party libraries) 3. Fancy effects that affect performance (e.g., excessive animations that interfere with readability). 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 animation logic/view/state management), composability of components, and proper use of uni-app patterns. 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 component is not properly encapsulated for reuse. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the dialogue UI follows modern chat interface design principles: 1) Distinct visual differentiation between robot and user messages 2) Proper bubble sizing and spacing (following the 8px multiple principle) 3) Professional typography (readable font size ≥ 14px, sufficient contrast). Deduct 3 points for cramped dialogue bubbles, 5 points for poor contrast between text and background, and 5 points for inconsistent styling between messages. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the animation effects conform to human perception characteristics: 1) Natural typing rhythm (neither too fast nor too slow) 2) Smooth scrolling when content exceeds viewport 3) Clear visual indicators during loading/processing states. Deduct 5 points for jerky text appearance, 3 points for failing to auto-scroll as new text appears, and 5 points for missing loading states during response generation. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "easy"
+}

package/library/web_applications-communication/ros-image-display-vue-flask.json

@@ -0,0 +1,68 @@
+{
+  "index": 1470,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and expert responses. Be sure the code you provide is executable and can be demonstrated. Implement displaying ROS images in a browser using Vue.js + Flask, and provide the code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the ROS image subscription and processing mechanism properly implemented?",
+      "description": "Verify if the code correctly subscribes to ROS image topics, handles different image formats (raw, compressed, etc.), and implements proper conversion to web-compatible formats (JPEG/PNG). Score 0 if ROS image subscription is missing, 5 if basic subscription exists but without format handling, and 10 if it includes comprehensive error handling and format conversion for all common ROS image types.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Flask backend implementation complete and secure?",
+      "description": "Check if the Flask server properly initializes ROS nodes, provides appropriate endpoints (REST API or WebSocket) for image streaming, and includes security measures such as input validation and rate limiting. Deduct 3 points if CORS handling is missing, 3 points if there's no error handling for ROS node failures, and 5 points if there are no safeguards against potential memory leaks from unprocessed image buffers. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the Vue.js frontend implementation efficient and responsive?",
+      "description": "Evaluate whether the Vue.js application efficiently handles image rendering, implements reactive components for real-time updates, and provides image control features (zoom, pan, etc.). Deduct 3 points if images aren't efficiently cached, 5 points if there's no loading state management during image fetch, and 5 points if the UI freezes during high-frequency image updates. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the image streaming pipeline optimized for performance?",
+      "description": "Analyze whether the code implements efficient image streaming techniques such as WebSockets for real-time updates, appropriate image compression before network transfer, and client-side buffering/throttling. Score 0 if using only basic HTTP polling, 5 if using WebSockets without optimization, and 10 if implementing advanced techniques like adaptive quality based on network conditions and frame-skipping during congestion.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as ROS node failures, network interruptions, image corruption, 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. Multi-camera view switching 2. Overlay capabilities for sensor fusion 3. Time-synchronized playback with other ROS data). 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 image processing operations that could impact performance 2. Unnecessary DOM manipulations outside Vue's reactivity system 3. Over-engineered solutions for simple problems (e.g., complex state management for basic image display). 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 ROS interface/image processing/UI components), proper error handling, and build process configuration. Deduct 5 points if global state is overused or Vue component design principles are violated; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no proper development/production environment configuration. 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 with good contrast for image visibility 2) Proper layout spacing that maximizes image viewing area 3) Clean, non-intrusive controls that don't obscure important image content. Deduct 3 points for each UI element that obscures image content unnecessarily, 5 points for poor contrast making images hard to see, and 5 points for chaotic control placement. 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) Image loading indicators appear within 100ms 2) Smooth transitions between images/camera views 3) Responsive controls with clear visual feedback. Deduct 5 points for image displays without loading states, 5 points for jittery or choppy image rendering during high-frequency updates, and 3 points for interaction delays exceeding 200ms. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "medium"
+}

package/library/web_applications-communication/rust-nuxt-windows-im-client.json

@@ -0,0 +1,68 @@
+{
+  "index": 1447,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable and demonstrable. Please build an IM client using Rust and Nuxt - a PC client specifically. No need to build the server side. I need to run this client on Windows.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Rust-Nuxt integration architecture properly implemented?",
+      "description": "Evaluate whether the code establishes a robust architecture that bridges Rust backend logic with Nuxt frontend. Look for proper use of FFI (Foreign Function Interface) patterns like tauri, napi-rs, or rust-webpack. Score 0 if there's no integration between Rust and Nuxt, 5 points if basic integration exists but with architectural flaws, 10 points for a clean, maintainable architecture with proper separation of concerns.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the IM core functionality implemented in Rust?",
+      "description": "Check whether essential IM features (message handling, connection management, encryption) are implemented in Rust. The Rust code should handle networking, security protocols, and persistent storage. Deduct 5 points if network connection management is missing, 3 points if encryption is absent, and 2 points if offline message handling is not implemented. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the Nuxt UI implementation complete with necessary IM components?",
+      "description": "Assess whether the Nuxt frontend includes all necessary IM UI components: chat list, conversation view, message composition area, contact management, and notification system. Score 0 if major components are missing, 5 points if basic functionality exists but lacks polish, 10 points for a comprehensive implementation with proper component hierarchy and state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is Windows compatibility ensured for distribution and execution?",
+      "description": "Verify that the application can be built for and run on Windows systems. Check for proper build configuration (static linking of C/C++ dependencies), Windows-specific path handling, and system integration features like startup, notifications, and taskbar integration. Deduct 5 points if the build process isn't automated for Windows, 3 points if Windows-specific features aren't handled properly. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common IM-specific abnormal situations (network instability, malformed messages, authentication failures) and provides friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully handle connection drops, message failures, and user errors. Give 10 points for comprehensive error handling, 5 points for average robustness, and 0 points if exceptions are unhandled.",
+      "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. End-to-end encryption with key verification 2. Custom message formatting with Markdown 3. Voice/video message support 4. Smart notification management based on user activity). 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 ways to handle the same message type) 2. Function modules unrelated to IM functionality (e.g., built-in games not related to messaging) 3. Fancy effects that affect performance (e.g., excessive animations or effects that slow down message display). 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 (separating network/UI/persistence layers), test coverage (unit tests for Rust, component tests for Nuxt), and build process automation. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate exceeds 30%; deduct 5 points if the build process isn't properly automated with cross-platform support. 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 modern messaging app design principles: 1) Consistent color scheme with clear read/unread states 2) Proper message bubble spacing and alignment 3) Professional typography hierarchy for messages vs. metadata. Deduct 3 points for cluttered conversation views, 5 points for poor information hierarchy, and 5 points for inconsistent visual language between different sections. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the IM-specific interactions meet user expectations: 1) Message send/receive feedback under 100ms 2) Smooth scrolling through message history 3) Real-time typing indicators and read receipts 4) Seamless state transitions between online/offline modes. Deduct 5 points for laggy message rendering, 3 points for jerky scrolling, and 5 points for unclear connection status indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Communication",
+  "difficulty": "hard"
+}