@getollie/cli 0.0.5 → 0.2.0

package/library/web_applications-web_visuals/python-semantic-ui-webpage-creation.json

@@ -1,68 +0,0 @@
-{
-  "index": 969,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. You're a code expert. Please use your professional knowledge to generate accurate and expert responses. Be sure the code you generate is executable for demonstration. Create a simplified webpage using Python with Semantic UI.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Python web framework properly implemented?",
-      "description": "Evaluate whether the code correctly uses a Python web framework (Flask, Django, etc.) with proper routing, request handling, and serving static files. Check for middleware configuration, environment variable handling, and appropriate HTTP response codes. Score 0 if no framework is used, 5 if basic implementation is present but with flaws, 10 if properly implemented with error handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is Semantic UI correctly integrated?",
-      "description": "Check if Semantic UI CSS/JS files are properly linked (either via CDN or local installation), and whether the correct version is specified. Verify that Semantic UI components are used according to documentation standards with proper class names and nesting. Deduct 5 points if linked incorrectly, 3 points if outdated version used, and 2 points if JS initialization is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the webpage have a responsive design?",
-      "description": "Analyze whether the webpage uses Semantic UI's responsive grid system correctly, with proper breakpoints for different screen sizes. Check if the layout adjusts appropriately on mobile, tablet and desktop views. Deduct 5 points if no responsive grid is implemented, 3 points if elements overflow on small screens, and 2 points if mobile menu is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are Semantic UI components used effectively?",
-      "description": "Evaluate the appropriate use of Semantic UI components (menus, cards, buttons, forms, etc.) according to their intended purpose. Check for proper semantic markup with correct class hierarchies. Deduct 3 points for each improperly used component, 2 points for missing interactive behaviors, and 5 points if no Semantic UI-specific components are used. 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, missing data, server 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. Dynamic theme switching 2. Custom animations with Semantic UI transitions 3. Interactive data visualizations). 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 imports or libraries that aren't used 2. Over-engineered solutions for simple tasks 3. Excessive use of Semantic UI components where simpler HTML would suffice. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functionality is overcomplicated by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating routes/templates/static files), appropriate commenting, and adherence to Python best practices (PEP 8). Deduct 5 points for global variable abuse or non-idiomatic Python; deduct 5 points if the code structure is monolithic; deduct 5 points if there's no separation of 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 consistent principles) 3) Professional typography (appropriate font sizes and legibility). 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 transitions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Web Visuals",
-  "difficulty": "easy"
-}

package/library/web_applications-web_visuals/react-ant-design-text-flipping-function.json

@@ -1,68 +0,0 @@
-{
-  "index": 1425,
-  "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 can be demonstrated. Please help me write a text flipping function using React and Ant Design UI.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the text flipping function core implementation complete?",
-      "description": "Examine whether the React component properly implements text flipping animation with appropriate state management. Check if it handles different text types (single/multi-line), allows configuration of flipping direction (horizontal/vertical), and maintains text readability during animation. Score 0 if core flipping functionality is missing, 5 for basic implementation, 10 if fully configurable with multiple animation options.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is Ant Design UI properly integrated?",
-      "description": "Verify that the implementation correctly uses Ant Design components following their API specifications rather than just basic HTML elements. Check if proper Ant Design theming is applied, component props are used correctly, and the solution follows Ant Design's design principles. Deduct 5 points if Ant Design is barely used, 3 points if used incorrectly or inconsistently. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the component flexible and customizable?",
-      "description": "Evaluate if the component accepts customization props for animation speed, timing functions, delay, text content, styles, and integration with other Ant Design components. Check if it exposes appropriate callback events (onFlipStart, onFlipComplete). Deduct 3 points for each missing essential customization option. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is accessibility properly implemented?",
-      "description": "Check if the text flipping animation is accessible - including proper ARIA attributes, keyboard navigability, respecting reduced motion preferences, and maintaining text contrast during animation. The component should work with screen readers and include proper focus management. Deduct 3 points for each accessibility issue found. 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 empty text, extremely long text, rapid state changes, etc.) and provide friendly error handling or fallback 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. 3D perspective flipping effects 2. Ability to flip only portions of text or characters sequentially 3. Integration with React transitions/motion libraries like react-spring). 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 state management (e.g., duplicate state for the same functionality) 2. Unnecessary re-renders caused by implementation issues 3. Fancy effects that affect performance without adding value to the text flipping functionality. 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 structure (separation of concerns, proper hooks usage), TypeScript/PropTypes usage, and code organization. Deduct 5 points if props are not properly typed or documented; deduct 5 points if there are useState/useEffect anti-patterns; deduct 5 points if the component structure violates React best practices. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the flipping animation follows modern design principles: 1) Smooth transitions with appropriate easing functions 2) Maintains visual hierarchy during animation 3) Follows Ant Design's aesthetic guidelines. Deduct 3 points for jarring or disruptive animations, 5 points for animations that make text difficult to read, and 5 points for designs that clash with Ant Design's visual language. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the animation performs well: 1) Animation runs at 60fps without frame drops 2) Transition duration is appropriate (300-500ms) 3) Animation doesn't cause layout shifts or reflows. Deduct 5 points for each noticeable performance issue, 3 points for animations that feel too fast or too slow, and 5 points for animations that cause visual glitches or browser rendering issues. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Web Visuals",
-  "difficulty": "easy"
-}

package/library/web_applications-web_visuals/react-antd-windows-desktop-menu-design.json

@@ -1,68 +0,0 @@
-{
-  "index": 1483,
-  "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. React+antd4 javascript simulating Windows desktop menu design.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Windows desktop menu structure accurately implemented?",
-      "description": "Review whether the code accurately implements the hierarchical structure of a Windows desktop menu, including Start menu, right-click context menus, taskbar interactions, and system tray functionality. Score 0 if none of these elements are implemented, 5 if only basic menu structure exists, and 10 if the implementation includes cascading menus, proper grouping, and visual separators matching Windows standards.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the essential Windows menu interactions implemented?",
-      "description": "Check whether all core Windows menu interactions are implemented: click and hover behaviors, keyboard navigation support (Tab, arrows, shortcuts), and proper focus management. Deduct 3 points if keyboard accessibility is missing, 3 points if hover states are incorrect, and 3 points if focus behavior doesn't match Windows patterns. Full score requires implementing Esc key to close menus and proper event bubbling prevention.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the visual styling faithful to Windows design patterns?",
-      "description": "Evaluate whether the styling properly follows Windows desktop UI standards, including correct colors, borders, shadows, fonts (Segoe UI), and spacing. Look for accurate implementation of hover/focus/active states, highlighting of selected items, and proper icons. Deduct 5 points if the styling lacks key Windows visual cues, and 3 points if animations (like fade/slide effects) are missing or incorrect.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the implementation integrate React with Ant Design effectively?",
-      "description": "Assess the technical integration between React and Ant Design components. Check for proper use of Ant Design's Menu, Dropdown, and Popover components while maintaining Windows aesthetics. Review the component structure for logical hierarchy and reuse. Deduct 5 points if Ant Design components are significantly customized to mimic Windows style (contradicting library purpose), and 3 points if React hooks usage is suboptimal.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code handles edge cases such as dynamic menu content, window resizing, screen boundaries for submenus, empty menu states, and long menu item text. Code with strong robustness should prevent menu overflow outside viewport boundaries and handle high-contrast modes. Score 10 points if all edge cases are handled, 5 points if only basic error handling exists, and 0 points if no robustness considerations are 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 the experience (e.g., 1. Live folder previews, 2. Recent files integration, 3. Custom theme support like Windows theme switching, 4. Drag and drop reordering of menu items). 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 menu opening mechanisms) 2. Function modules unrelated to Windows desktop experience (e.g., unnecessary animations) 3. Complex features that affect performance (e.g., excessive DOM nesting or unnecessary re-renders). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core Windows menu experience is compromised by extraneous code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating menu components/logic/styles), proper React patterns (hooks, context API usage, memoization), and component reusability. Deduct 5 points if global state management is poor or prop drilling is excessive; deduct 3 points if component responsibilities are poorly defined; deduct 3 points if performance optimizations like React.memo or useMemo are missing where needed. 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 Windows design principles: 1) Proper color palette matching Windows themes 2) Consistent padding and margins (8px grid system) 3) Appropriate font usage (Segoe UI or system-ui, proper sizing hierarchy). Deduct 3 points for each UI element that breaks Windows consistency, 5 points for significant visual discrepancies from Windows standards, 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 menu interactions feel native to Windows: 1) Opening/closing animations match Windows speed (200-250ms) 2) Click response feels immediate (≤100ms) 3) Submenu flyouts appear with appropriate timing and direction. Deduct 5 points for janky animations, 3 points for menu flickering during interactions, and 5 points for noticeable delays in menu response. Check if hovering behavior for cascading menus follows Windows patterns with appropriate timing. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Web Visuals",
-  "difficulty": "easy"
-}

package/library/web_applications-web_visuals/react-single-page-application-development.json

@@ -1,68 +0,0 @@
-{
-  "index": 1096,
-  "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. Use React to build a single-page application.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is a complete React single-page application structure implemented?",
-      "description": "Check if the code includes essential React application components: entry point (index.js/tsx), App component, routing system, and proper component hierarchy. Verify that create-react-app or another modern React setup is properly configured. Score 0 if only fragments are provided without a proper structure, 5 if basic structure exists but lacks organization, and 10 if a complete, well-organized SPA structure is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the application implement proper routing and navigation?",
-      "description": "Evaluate if React Router (or equivalent) is properly implemented with multiple routes, navigation components, and guards for protected routes if applicable. Check for URL parameter handling and proper history management. Deduct 3 points if only basic routing exists without nested routes, 5 points if there's no 404 handling, and 3 points if navigation state isn't preserved between rerenders. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is state management implemented effectively?",
-      "description": "Assess state management approach (useState, useReducer, Redux, Context API, etc.). Verify that global and component state are appropriately separated, and state updates don't cause unnecessary re-renders. Deduct 5 points for prop drilling beyond 3 levels, 3 points for inefficient state updates causing performance issues, and 5 points if no centralized state management is used when clearly needed. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are React hooks used correctly and optimally?",
-      "description": "Check for proper implementation of React hooks (useState, useEffect, useCallback, useMemo, useRef, etc.) and adherence to the Rules of Hooks. Watch for dependency arrays in useEffect and memoization hooks. Deduct 3 points for each hook rule violation, 5 points for memory leaks in useEffect, and 5 points for excessive re-renders due to improper hook usage. 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, invalid user inputs, loading states, etc.) and provide friendly error boundaries 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. Performance optimizations like virtualized lists 2. Accessibility features beyond basic ARIA 3. Progressive Web App 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 state management solutions coexisting) 2. Function modules unrelated to core requirements 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 component structure (atomic design principles, reusability), code splitting implementation, and build process optimization. Deduct 5 points if components exceed 300 lines; deduct 3 points if prop types or TypeScript types are missing; deduct 5 points if no code splitting is implemented for larger bundles. Check for ESLint/Prettier 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) Consistent component styling (e.g., using styled-components, CSS modules, or a UI library) 2) Proper responsive design with media queries or fluid layouts 3) Professional typography system with proper hierarchy. Deduct 3 points for inconsistent styling between components, 5 points for non-responsive layouts, and 5 points for accessibility issues (contrast, focus indicators). 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) Loading states for asynchronous operations 2) Smooth transitions between routes with proper animations 3) Form validation with immediate feedback. Deduct 5 points for missing loading indicators, 3 points for jarring page transitions, and 5 points for delayed user feedback after actions. Check for optimization techniques like debouncing for search inputs. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Web Visuals",
-  "difficulty": "easy"
-}

package/library/web_applications-web_visuals/rural-courtyard-six-bedrooms-html-design.json

@@ -1,68 +0,0 @@
-{
-  "index": 1776,
-  "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 display. Design a rural courtyard with six bedrooms, two living rooms, and one kitchen, and draw it using HTML.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the rural courtyard layout completely implemented?",
-      "description": "Verify whether the HTML code properly implements the required layout with six bedrooms, two living rooms, and one kitchen in a rural courtyard style. Score 0 if the core layout is missing elements, 5 if all required rooms are present but poorly arranged, and 10 if the layout is complete and logically arranged in a courtyard formation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the architectural structure accurately represented?",
-      "description": "Examine whether the courtyard design includes appropriate structural elements (walls, doors, windows, roofs) with correct proportions and rural characteristics. Deduct 3 points if structural elements are missing, 3 points if proportions are unrealistic, and 4 points if the rural style is not evident. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the room relationships and connections logically designed?",
-      "description": "Evaluate whether the connections between rooms make architectural sense (e.g., bedrooms with proper privacy, kitchen accessible from living areas, logical doorways and pathways). Deduct 5 points for illogical room arrangements, 3 points for missing critical pathways, and 2 points for poor flow between spaces. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the courtyard component appropriately incorporated?",
-      "description": "Check if the design includes a proper courtyard element that integrates well with the building structure in rural style. Deduct 5 points if the courtyard is missing or poorly defined, 3 points if it lacks rural characteristics, and 2 points if its relationship with surrounding rooms is poorly conceived. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle different screen sizes, browser compatibility issues, and ensures proper rendering across devices. Code with strong robustness should use responsive design principles and fallback options, giving 10 points. If the robustness is average with partial responsiveness, give 5 points, and if the design breaks on different screen sizes, 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. Interactive room exploration 2. Day/night lighting simulation 3. Rural-appropriate decorative elements). 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 HTML elements or CSS styles that serve the same purpose 2. Excessive decorative elements that distract from the main layout 3. Fancy effects that affect loading performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core layout is interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review HTML structure (semantic HTML usage), CSS organization (systematic class naming, separation of concerns), and code maintainability. Deduct 5 points if non-semantic div-soup is prevalent; deduct 5 points if styles are inline rather than properly organized; deduct 5 points if the code lacks comments or organization. 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 appropriate for a rural setting 2) Proper layout proportions reflecting architectural reality 3) Consistent visual style throughout the courtyard. Deduct 3 points for jarring visual elements, 5 points for unrealistic architectural representations, and 5 points for inconsistent visual styling. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the visual representation clear and intuitive?",
-      "description": "Judge whether the visual representation clearly communicates the rural courtyard design: 1) Clear distinction between different room types 2) Intuitive understanding of the floor plan 3) Visual hierarchy that prioritizes important elements. Deduct 5 points for confusing room identification, 3 points for unclear boundaries between spaces, and 5 points for poor visual differentiation of architectural elements. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Web Visuals",
-  "difficulty": "medium"
-}

package/library/web_applications-web_visuals/traffic-light-web-interface.json

@@ -1,68 +0,0 @@
-{
-  "index": 992,
-  "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. You only need to create a simple web interface that can display traffic light timing, vehicle speed, and video.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the traffic light timing system fully implemented?",
-      "description": "Review whether the code accurately implements traffic light state management with proper timing sequences (red/yellow/green cycles). Check if the timing display shows countdown or elapsed time, and whether the light transitions follow realistic traffic patterns. Score 0 if no timing logic is implemented, 5 if only basic color switching exists, and 10 if complete timing control with configurable intervals is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the vehicle speed monitoring functionality implemented?",
-      "description": "Check whether the speed display includes real-time updates, proper unit conversion (mph/kmh), and realistic speed simulation or input mechanisms. Evaluate if speed data is presented clearly with appropriate formatting and decimal precision. Deduct 5 points if speed updates are jerky or unrealistic, and 3 points if unit display is unclear. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the video display component properly integrated?",
-      "description": "Evaluate whether the video element is properly embedded with standard HTML5 video controls, appropriate sizing, and fallback mechanisms for unsupported formats. Check if video loading states are handled gracefully and if the video integrates well with other interface elements. Deduct 5 points if video fails to load or has no error handling, and 3 points if controls are poorly positioned. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the integrated traffic monitoring interface cohesive?",
-      "description": "Check whether all three components (traffic light, speed display, video) work together as a unified traffic monitoring system. Evaluate if the interface provides logical grouping, consistent data refresh rates, and synchronized updates. Deduct 5 points if components appear disconnected or have conflicting update cycles, and 3 points if the overall system lacks coherent workflow. Give 10 points if fully integrated with cross-component interactions.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as video loading failures, invalid speed values, timing interruptions, browser compatibility issues, 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 traffic monitoring experience (e.g., 1. Speed limit violation alerts 2. Traffic flow statistics 3. Emergency mode with flashing lights 4. Historical data charts). 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 timer mechanisms coexisting) 2. Function modules unrelated to traffic monitoring (e.g., a built-in music player or social features) 3. Fancy effects that affect performance (e.g., excessive particle animations on traffic lights). 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 traffic light logic/speed monitoring/video handling), proper variable naming, and code organization. Deduct 5 points if global state pollution is found or no separation of concerns; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no proper event handling or DOM manipulation patterns are used. 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 UI principles: 1) Harmonious color matching with appropriate traffic light colors 2) Proper layout spacing with clear visual hierarchy 3) Professional typography with readable font sizes (≥14px) and appropriate contrast ratios. Deduct 3 points for each crowded visual element, 5 points for poor color contrast or confusing traffic light representation, and 5 points for chaotic 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 user expectations: 1) Traffic light transitions are smooth with appropriate timing 2) Speed updates are fluid without jarring jumps 3) Video controls respond immediately to user input 4) Overall interface updates are synchronized and performant. Deduct 5 points for each laggy interaction, 3 points for choppy animations, and 5 points for unresponsive controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Web Visuals",
-  "difficulty": "easy"
-}

package/library/web_applications-web_visuals/unity-cloud-rendering-html-interaction.json

@@ -1,68 +0,0 @@
-{
-  "index": 772,
-  "question": "You are a code expert. Please utilize your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration. Help me write an HTML page where I need to embed a Unity cloud rendering URL and interact with it.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the HTML page correctly structured for embedding a Unity WebGL application?",
-      "description": "Check whether the HTML document has proper DOCTYPE declaration, meta tags, and follows HTML5 standards. Verify if the Unity iframe or container div is structured correctly with appropriate dimensions and responsive design considerations. Deduct 5 points if responsive design is missing, 3 points if incomplete meta tags, and 2 points if semantic HTML elements are not used. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Unity cloud rendering URL properly integrated?",
-      "description": "Evaluate whether the code uses the correct embedding technique (iframe, WebGL container, etc.) for the Unity cloud rendering URL. Check for proper URL handling, loading states, and error handling when the Unity content is unavailable. Deduct 5 points if the embedding approach is incorrect, 3 points if loading indicators are missing, and 2 points if error states aren't handled. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the communication between HTML and Unity implemented?",
-      "description": "Review whether the code includes proper JavaScript bridge functions for bi-directional communication between the webpage and Unity application. Check if the implementation uses standard Unity external call patterns (e.g., SendMessage, JSLib) and properly handles asynchronous messaging. Deduct 5 points if bidirectional communication is missing, 3 points if event listeners are improperly implemented, and 2 points if security considerations are ignored. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the Unity interaction controls well-designed?",
-      "description": "Assess whether external UI controls for Unity interaction are implemented (like buttons, sliders, input fields) that can trigger actions in the Unity application. Check if the controls follow a consistent design pattern and provide visual feedback when interacting with Unity. Deduct 3 points if controls are inconsistently designed, 5 points if there's no visual feedback for interactions, and 2 points if control labeling is unclear. 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 Unity failing to load, network interruptions, browser compatibility issues, etc.) and provides 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. Custom loading animations while Unity initializes 2. Fullscreen toggle with proper UI adaptation 3. Performance monitoring with visual indicators). 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 perform the same Unity interaction) 2. Function modules unrelated to Unity integration (e.g., unnecessary animations or effects) 3. Fancy effects that affect performance (e.g., heavy background animations competing with Unity rendering). 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 logic/Unity communication/error handling), maintainability, and documentation quality. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 3 points if the code duplication rate is too high (over 30%); deduct 2 points if comments and documentation are insufficient. 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 between HTML UI and Unity content 2) Proper layout with clear separation between controls and Unity viewport 3) Professional font system and consistent styling. 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 for Unity communication 2) Proper loading and transition states when interacting with Unity 3) Clear visual guidance for available interactions. Deduct 5 points for each operation without feedback, 3 points for delayed Unity responses without indicators, and 5 points for confusing interaction patterns. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Web Visuals",
-  "difficulty": "easy"
-}

package/library/web_applications-web_visuals/vue-3-amap-autonavi-3d-map-building-blocks.json

@@ -1,68 +0,0 @@
-{
-  "index": 1346,
-  "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 purposes. Implement Amap (AutoNavi) API using Vue 3 to create a 3D map and draw building blocks.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Vue 3 application structure correctly set up?",
-      "description": "Check if the code properly initializes a Vue 3 application with appropriate component architecture. Verify the presence of Vue 3 specific features like Composition API, proper lifecycle hooks, and reactive data management. Score 0 if Vue 3 is not used, 5 if basic implementation exists but with improper structure, and 10 if properly structured with clean component design patterns.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Amap (AutoNavi) API integration complete?",
-      "description": "Assess whether the Amap API is correctly loaded, initialized with valid keys, and properly integrated. Check for error handling in API loading process and key validation. Deduct 5 points if the API key management is insecure, 3 points if version compatibility issues exist. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the 3D map functionality properly implemented?",
-      "description": "Evaluate if the code correctly initializes a 3D map view with proper view settings (pitch, rotation, zoom levels). Check if the 3D buildings layer is enabled and correctly configured. Score 0 if 3D view is missing, 5 if basic 3D functionality exists but with incorrect parameters, and 10 if fully implemented with optimized 3D rendering settings.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the building block drawing functionality complete?",
-      "description": "Verify if the code includes methods to draw custom building blocks with appropriate geometry (polygons, extrusions), proper height calculations, and styling options. Check if it includes options for custom colors, textures and opacity. Deduct 5 points if custom building geometry lacks precision, 5 points if height calculations are not dynamic or configurable. 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 loading failures, invalid coordinates, rendering 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. Dynamic building highlighting on hover 2. Custom building information popups 3. Animation of building creation/modification). 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 API initializations or map instances 2. Unnecessary feature loading unrelated to 3D buildings or map functionality 3. Excessive effects that impact map 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 modular design (such as separating map services/UI components/data handling), component reusability, and performance optimization techniques. Deduct 5 points if global state pollution is found; deduct 5 points if the code lacks proper documentation for API parameters; deduct 5 points if there's no optimization for large building datasets. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the map visualization follows modern design principles: 1) Appropriate map style selection for 3D buildings 2) Clean UI controls for map navigation 3) Professional color scheme for building representation (avoiding visual clutter). Deduct 3 points for cluttered controls, 5 points for poor color contrast between buildings and base map, and 5 points for illegible labels or building information. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the map interactions conform to user expectations: 1) Smooth camera transitions during navigation ≤ 500ms 2) Responsive building selection and information display ≤ 100ms 3) Efficient rendering during zoom/pan operations without jank. Deduct 5 points for laggy camera movements, 3 points for delayed building highlighting, and 5 points for freezes during building data updates. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Web Visuals",
-  "difficulty": "easy"
-}