@getollie/cli 0.0.1

package/library/management_systems-hardware_management/web-driven-mouse-config-hid-protocol.json

@@ -0,0 +1,68 @@
+{
+  "index": 1429,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable for demonstration purposes. Develop a web-driven website about mice that can configure mouse buttons and DPI settings through the mouse's HID protocol.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the HID protocol implementation complete?",
+      "description": "Review whether the code correctly implements the HID protocol for mouse interaction, including reading device descriptors, sending/receiving control transfers, and handling feature reports. Check if the implementation supports USB standard HID reports (0x01-0x03) and vendor-specific reports. Score 0 if HID communication is not implemented, 5 if basic read/write operations are implemented, and 10 if the full protocol including error handling is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the mouse button configuration functionality comprehensive?",
+      "description": "Evaluate whether the code allows complete button remapping (primary, secondary, tertiary buttons, side buttons, scroll wheel buttons), macros assignment, and profile management. Check if the implementation handles button event propagation correctly. Deduct 3 points if only basic remapping is supported, 5 points if macro functionality is missing, and 7 points if profile management is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the DPI settings system properly implemented?",
+      "description": "Check whether the code implements multi-level DPI settings with visual indicators, on-the-fly DPI switching, and axis-independent DPI configuration (X/Y separate values). Verify that the implementation correctly calculates and applies the appropriate values to the mouse hardware. Deduct 3 points for each missing feature. Give 10 points for comprehensive implementation with DPI visualization and real-time preview.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the web interface communication with hardware devices secure and efficient?",
+      "description": "Evaluate the implementation of Web HID API usage, permission handling, and device connection management. Check if the code includes device detection, connection retries, and disconnection handling. Verify proper error messages when hardware access is denied. Deduct 5 points if no permission handling exists, 3 points if connection state management is poor, and 3 points if there's no error recovery mechanism. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common edge cases (unsupported devices, permission denials, disconnections during configuration, browser compatibility issues). Code with strong robustness should include feature detection, graceful degradation, and informative error messages. Give 10 points for comprehensive edge case handling, 5 points for basic error handling, and 0 points if exceptions are unmanaged.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time input visualization 2. Heatmap of button usage 3. Advanced macro recording with timing preservation 4. Sensor calibration tools). Add 2.5 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 device polling mechanisms 2. Unnecessary device reconnection attempts 3. Excessive or duplicate UI elements for the same function. 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 (separation of device communication, UI, state management), error handling strategies, and cross-browser compatibility. Deduct 3 points if global state pollution exists, 4 points if no abstraction layers separate hardware communication from UI logic, and 3 points if no fallback mechanisms exist for unsupported browsers. 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) Mouse visualization is accurate and proportional 2) Configuration controls are logically grouped and labeled 3) Visual feedback indicates active settings and changes. Deduct 3 points for cluttered layouts, 3 points for confusing button/control labeling, and 4 points for lack of visual feedback during configuration. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects enhance usability: 1) Real-time preview of button assignments 2) Visual confirmation of DPI changes 3) Clear indication of connection status 4) Smooth transitions between configuration screens. Deduct 2.5 points for each missing interaction enhancement. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Hardware Management",
+  "difficulty": "hard"
+}

package/library/management_systems-hardware_management/web-joystick-esp32-car-control.json

@@ -0,0 +1,68 @@
+{
+  "index": 1204,
+  "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. Now I need you to simply create a program where a virtual joystick on a webpage controls the movement of a small car with four motors. The main controller board is an ESP32.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the virtual joystick UI implementation complete and intuitive?",
+      "description": "Evaluate if the HTML/CSS/JavaScript implementation creates a responsive, touch-compatible joystick that provides clear visual feedback. Check if it tracks both X/Y position with appropriate sensitivity and returns to center when released. Score 0 if no visual joystick exists, 5 if basic implementation without proper touch events, 10 if fully responsive with visual feedback and smooth touch/mouse interaction.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the motor control logic properly implemented on the ESP32?",
+      "description": "Review the ESP32 code for proper motor driver initialization, PWM setup and pin control. Check if the code handles differential steering (different speeds on left/right wheels) and includes proper ramping to avoid sudden starts/stops. Deduct 5 points if motor safety limits are missing, 3 points if PWM frequency is inappropriate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the communication between the web interface and ESP32 properly established?",
+      "description": "Assess if WebSocket or HTTP protocol implementation is complete with proper handshaking, error handling, and reconnection capabilities. Check if the communication handles connection drops gracefully. Deduct 5 points if the communication is one-way only, 3 points if security measures like CORS or authentication are missing, and 5 points if no connection status is displayed to users. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the control translation from joystick position to motor commands accurate?",
+      "description": "Verify the mathematical model that converts joystick X/Y coordinates to individual motor speeds. Check for proper handling of steering angles, forward/reverse transitions, and speed control. Deduct 5 points if the algorithm doesn't support diagonal movement, 3 points if speed scaling is linear rather than exponential for fine control, and 5 points if no deadzone handling exists. 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 connection loss, erratic joystick input, motor stalls, low battery, 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. Battery level indicator 2. Speed/distance telemetry visualization 3. Obstacle detection feedback 4. Custom control profiles). 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 joystick libraries coexisting) 2. Function modules unrelated to car control (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., excessive CSS transitions). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/communication/motor control layers), exception handling, and code organization. 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 proper comments and documentation are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional visual hierarchy (clear distinction between control elements and feedback displays). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for poor mobile responsiveness. 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) Joystick response delay ≤ 100ms 2) Car movement feedback within 200ms 3) Smooth animation for joystick movement. Deduct 5 points for noticeable input lag, 3 points for jerky joystick movement, and 5 points if the car response doesn't match joystick position accurately. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Hardware Management",
+  "difficulty": "hard"
+}

package/library/management_systems-hardware_management/wifi-sharing-mini-program-advertisement-integration.json

@@ -0,0 +1,68 @@
+{
+  "index": 1058,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable. Create a mini program for WiFi sharing, with interfaces reserved for advertisement integration.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the WiFi sharing core functionality implemented?",
+      "description": "Evaluate whether the code implements the essential WiFi sharing mechanism, including scanning available networks, displaying WiFi information (SSID, signal strength, security type), and generating QR codes or other sharing methods. Score 0 if core functionality is missing, 5 if only basic display is implemented, and 10 if complete with encryption handling and connection verification.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the advertisement integration interface properly designed?",
+      "description": "Check if the code includes well-defined interfaces for ad integration (banner ads, interstitial ads, rewarded ads). Verify if placeholder components are strategically positioned without disrupting user flow, with proper event hooks for ad loading/display. Deduct 5 points if interfaces are poorly defined, 3 points if ad placements interfere with core functionality. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the program handle WiFi permissions and security appropriately?",
+      "description": "Assess whether the code properly requests and handles necessary permissions (location services for WiFi scanning, network access). Verify if it implements security measures to protect sensitive WiFi credentials (password encryption/masking, secure sharing). Deduct 5 points for missing permission handling, 5 points for security vulnerabilities. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is cross-platform compatibility addressed?",
+      "description": "Evaluate whether the mini program works across multiple platforms (Android/iOS/Web), with appropriate platform detection and conditional logic for platform-specific WiFi APIs. Check if it gracefully degrades functionality when certain features aren't available. Deduct 5 points if major platforms are unsupported, 3 points if platform-specific bugs exist. 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 permission denied, network unavailable, disconnected WiFi, invalid credentials) 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. WiFi speed testing functionality 2. Password strength assessment 3. Connection history with usage statistics 4. Automatic reconnection to preferred networks). 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 WiFi scanning methods coexisting) 2. Function modules unrelated to WiFi sharing (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., excessive animations when displaying WiFi lists). 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 WiFi service/UI/ad integration layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast scanning updates, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Hardware Management",
+  "difficulty": "easy"
+}

package/library/management_systems-hardware_management/windows-remote-desktop-multi-ip-management.json

@@ -0,0 +1,68 @@
+{
+  "index": 1689,
+  "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. Help me write a program that mimics Windows Remote Desktop, with the requirement that it can manage multiple IP addresses. Other functionality should remain unchanged.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the IP address management system fully implemented?",
+      "description": "Review whether the code implements a comprehensive IP address management system including adding, editing, deleting, and validating IP addresses. Check for categorization options (e.g., by department, frequency of use), search/filter functionality, and batch operations. Score 0 if no IP management exists, 5 if only basic CRUD operations are available, and 10 if advanced management features are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the remote desktop connection functionality properly implemented?",
+      "description": "Evaluate whether the code correctly implements RDP protocol or utilizes appropriate libraries (e.g., FreeRDP, xfreerdp, Remmina) with proper parameters. Check if connection settings like screen resolution, color depth, audio redirection, and clipboard sharing are configurable. Deduct 5 points if the connection implementation is incomplete, and 3 points if advanced options are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are authentication mechanisms secure and comprehensive?",
+      "description": "Check if the code implements secure authentication methods (username/password, certificates, multi-factor authentication), credential storage (encrypted, not plain text), and session management. Evaluate whether it includes timeout settings and secure credential handling. Deduct 5 points for plaintext password storage, 3 points for missing credential management UI, and 5 points for lack of session security features. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is session management and multi-connection handling implemented?",
+      "description": "Review if the code properly manages multiple concurrent RDP connections, allows switching between active sessions, and implements features like thumbnails of active connections, connection status indicators, and session restoration. Check for proper resource allocation and release when connecting/disconnecting. Deduct 5 points if simultaneous connections aren't supported, 3 points if session state isn't preserved. 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 network timeouts, authentication failures, dropped connections, invalid IP formats) and provide friendly error prompts or recovery mechanisms. Check for proper exception handling, logging, and automatic reconnection attempts. 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. Auto-discovery of machines on local network 2. Performance monitoring of remote sessions 3. Screen recording/session playback 4. Wake-on-LAN integration 5. Custom connection profiles with different security levels). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar connection methods 2. Function modules unrelated to remote desktop management (e.g., a built-in web browser) 3. Fancy effects that affect performance (e.g., unnecessary animations in the connection interface). 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 connection logic/UI/credential management), unit test coverage, and build process automation. Check for proper error handling, logging, and configuration management. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching consistent with Windows UI guidelines 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times) 4) Intuitive connection status indicators. Deduct 3 points for each crowded visual element, 5 points for inconsistent styling with Windows UI, 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) Connection initiation feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance during connection process. Evaluate responsiveness during connection establishment and remote session interaction. Deduct 5 points for each operation without feedback, 3 points for laggy interface transitions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Hardware Management",
+  "difficulty": "hard"
+}

package/library/mermaid_flowcharts-logic_flowcharts/digital-twin-long-boom-assembly-bs-architecture.json

@@ -0,0 +1,68 @@
+{
+  "index": 1415,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the generated code is executable whenever possible. Based on the following content, please help me design a diagram.\n\nDevelop a digital twin system for controlling deviations in long boom assembly processes based on the Browser-Server (BS) architecture model, as shown in the figure. Adopt a front-end and back-end separation development model to improve system maintainability and development efficiency. The back-end algorithm model is developed using Python language, while the front-end builds an interactive user interface through the modern JavaScript framework React. The system uses MySQL database to process and store large amounts of data and interacts with the back-end through APIs. The Fetch API, an HTTP client library, is used to implement communication between the front-end and back-end.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the digital twin system architecture properly designed?",
+      "description": "Evaluate whether the code implements a complete BS architecture with clear front-end/back-end separation. Check if React is properly integrated on the front-end and Python on the back-end, with appropriate API interfaces between them. The architecture should include data flow diagrams showing how information moves between components.0 points if basic architecture is missing, 5 points if only basic separation exists, 10 points if complete architecture with clear component responsibilities and data flows is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the long boom assembly process modeling accurate?",
+      "description": "Review whether the code includes accurate physical models representing the long boom assembly, incorporating key parameters like dimensions, articulation points, and deviation measurements. The model should handle various assembly states and predict potential deviations.0 points if boom assembly modeling is absent, 5 points if basic modeling exists without deviation handling, 10 points if comprehensive modeling with accurate physical properties and deviation prediction is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the deviation control algorithm implemented effectively?",
+      "description": "Examine the Python backend code for algorithms that detect, analyze, and correct deviations in the assembly process. Check for mathematical models, statistical analysis, and correction recommendations.0 points if no deviation control algorithm exists, 5 points if basic detection without correction recommendations is implemented, 10 points if comprehensive algorithms with predictive capabilities and correction strategies are present.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the front-end and back-end communication properly implemented?",
+      "description": "Check if the Fetch API implementation includes proper error handling, request/response formatting, authentication, and real-time data exchange capabilities. Verify that API endpoints are RESTful or follow consistent patterns.0 points if communication is broken, 5 points if basic communication works but lacks error handling or security, 10 points if robust communication with authentication, error handling, and optimized data transfer is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as sensor data corruption, network interruption, user operation errors, etc.) and provide friendly error prompts or recovery mechanisms.0 points if no exception handling exists, 5 points if basic error handling is present, 10 points if comprehensive exception handling with recovery mechanisms is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time 3D visualization of deviations 2. Predictive maintenance alerts 3. AR overlay for assembly guidance).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 visualization methods) 2. Function modules unrelated to digital twin objectives 3. Fancy effects that affect performance (e.g., unnecessary animations).Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating data processing/visualization/control logic layers), unit test coverage, and build process automation. Check database design for normalization and indexing.Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the dashboard design follows industrial visualization standards: 1) Clear information hierarchy 2) Appropriate use of color for status indication 3) Balanced data density without overwhelming users 4) Responsive design for different screen sizes.Deduct 3 points for each crowded visual element, 5 points for ineffective use of color in status indication, and 5 points for non-responsive layouts. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the digital twin visualization updates smoothly: 1) Real-time data updates without visible lag 2) Smooth transitions between different views/states 3) Intuitive interaction for adjustment and control 4) Clear visual feedback for user actions.Deduct 5 points for lagging visualizations, 3 points for abrupt transitions between states, and 5 points for unintuitive interaction patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Mermaid Flowcharts-Logic Flowcharts",
+  "difficulty": "medium"
+}

package/library/mermaid_flowcharts-logic_flowcharts/sample-code-retejs-vue-3-setup-script-syntax.json

@@ -0,0 +1,68 @@
+{
+  "index": 1639,
+  "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 demonstration purposes. Provide sample code for using Rete.js in Vue 3, using the setup script syntax sugar.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is Rete.js core integration properly implemented?",
+      "description": "Review whether the code correctly integrates Rete.js with Vue 3 setup syntax, including proper engine initialization, area plugin configuration, and connection plugin setup. Check if the node editor instance is properly created and mounted to DOM elements. Score 0 if core Rete engine is not initialized, 5 if only basic editor is created without plugins, and 10 if complete integration with all essential plugins (Area, Connection, Render) is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are custom nodes and sockets correctly defined and functional?",
+      "description": "Evaluate whether custom node types are properly defined with input/output sockets, control elements, and data processing logic. Check if nodes can be added to the editor, connected properly, and execute their intended functions. Deduct 5 points if socket connections don't work, 3 points if node controls are non-functional. Full score requires at least 2-3 different node types with proper socket definitions and working connections.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is Vue 3 reactivity system properly integrated with Rete.js?",
+      "description": "Check whether Vue 3's composition API (ref, reactive, computed) is correctly used to manage Rete.js state and provide reactive updates. Evaluate if changes in Vue components properly sync with Rete editor state and vice versa. Deduct 5 points if reactivity is broken or causes memory leaks, 3 points if state synchronization is inconsistent. Full score requires seamless two-way data binding between Vue and Rete.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the data flow processing engine implemented with proper execution logic?",
+      "description": "Assess whether the node graph can execute properly with data flowing through connections, including proper input validation, data transformation, and output generation. Check if the execution order respects node dependencies and handles circular references. Deduct 5 points if execution logic is missing, 3 points if data types are not properly validated. Full score requires complete data processing pipeline with error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid node connections, missing dependencies, component lifecycle issues, memory leaks from Rete instances, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases and provide proper cleanup on component unmount, 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. Custom node templates with drag-and-drop palette 2. Real-time preview of node execution results 3. Serialization/deserialization of node graphs 4. Minimap or zoom controls 5. Undo/redo functionality). 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 editor initialization logic) 2. Function modules unrelated to Rete.js demonstration (e.g., unnecessary UI components) 3. Overly complex examples that obscure the core Rete.js usage patterns. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core Rete.js demonstration is interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating node definitions, editor configuration, and Vue components), proper TypeScript usage if applicable, and Vue 3 best practices compliance. Deduct 5 points if global state pollution is found or composition API patterns are misused; deduct 5 points if code structure is poorly organized; deduct 5 points if dependencies are not properly managed. 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 for nodes and connections (no more than 3 primary colors) 2) Proper layout spacing (node editor container and controls follow consistent spacing) 3) Professional typography (readable node labels, proper font hierarchy). Deduct 3 points for each visually crowded element, 5 points for clashing color combinations, and 5 points for poor visual hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the node editor interactions conform to user expectations: 1) Node dragging responsiveness ≤ 16ms for 60fps 2) Connection creation with smooth bezier curves and visual feedback 3) Hover states and selection feedback are immediate and clear 4) Zoom and pan operations are fluid. Deduct 5 points for each laggy interaction, 3 points for poor visual feedback during operations, and 5 points for confusing interaction patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Mermaid Flowcharts-Logic Flowcharts",
+  "difficulty": "hard"
+}

package/library/mermaid_flowcharts-logic_flowcharts/vue-flow-architectural-contract-approval-diagram.json

@@ -0,0 +1,68 @@
+{
+  "index": 1069,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure that any code you provide is executable. Create a demonstration diagram of a contract approval process for an architectural design project based on vue-flow.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core contract approval process flow correctly implemented with vue-flow?",
+      "description": "Check whether the code correctly implements the architectural contract approval process using vue-flow, including proper node types (start, approval steps, decision points, end), directed edges with correct flow direction, and appropriate edge styles. Score 0 if vue-flow is not implemented at all, 5 if only basic nodes and edges are present without proper flow logic, and 10 if the complete architectural design approval process is accurately represented with appropriate node types and logical flow connections.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the approval stages for the architectural design project properly defined?",
+      "description": "Evaluate whether the demonstration includes all essential stages of an architectural design contract approval process (e.g., initial submission, preliminary review, technical evaluation, financial assessment, final approval, etc.). Deduct 2 points for each missing critical stage. Check if conditional paths and decision points are correctly implemented (e.g., reject/revise/approve branches). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the vue-flow interaction functionality properly implemented?",
+      "description": "Verify if essential vue-flow interactions are implemented, including: node dragging, connection creation/deletion, panning/zooming, node selection, and mini-map (if applicable). Test if custom interactions relevant to contract approval (like approval action buttons, status changes, document attachment) are functional. Deduct 2 points for each missing core interaction feature. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the demonstration include appropriate data models for architectural contracts?",
+      "description": "Check if the code implements proper data structures for architectural contract entities, including contract metadata (parties involved, project details, financial terms), approval history, current status tracking, and document references. Examine if state management is implemented correctly. Deduct 3 points if the data model is incomplete, 5 points if data persistence is missing, and 2 points if state updates don't trigger appropriate UI changes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid node connections, concurrent editing conflicts, network interruptions, loading large diagrams) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time collaboration functionality 2. Approval timeline visualization 3. Document preview integration 4. Automated notifications for stakeholders). 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 approve a contract) 2. Function modules unrelated to architectural contract approval (e.g., built-in chat that's not for approval communication) 3. Fancy effects that affect performance (e.g., excessive animations that slow down diagram 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 flow logic/UI components/data services), component reusability, and build process optimization. Deduct 5 points if global state pollution is found or proper Vue composition API/options API patterns are not followed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not optimized for vue-flow integration. 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 suitable for a professional architectural contract system (using color coding for approval states) 2) Proper layout spacing with clear visual hierarchy between the flow diagram and supporting UI elements 3) Professional font system appropriate for technical documentation. Deduct 3 points for each crowded visual element, 5 points for unclear node status indicators, and 5 points for poor readability of critical contract information. 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) Node dragging and connecting feels responsive (≤ 100ms feedback) 2) Transition animations for approval status changes are meaningful and appropriately timed (300-500ms) 3) Clear visual feedback for user actions like approvals/rejections. Deduct 5 points for laggy diagram manipulation, 3 points for confusing transition effects between approval states, and 5 points for unclear visual feedback when interacting with critical approval functions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Mermaid Flowcharts-Logic Flowcharts",
+  "difficulty": "easy"
+}

package/library/mermaid_flowcharts-mind_maps/mind-map-similar-to-xmind.json

@@ -0,0 +1,68 @@
+{
+  "index": 1051,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration purposes. Output a mind map similar to XMind, as visual representations are easier for humans to understand.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the mind map core structure fully implemented?",
+      "description": "Review whether the code accurately implements the hierarchical tree structure through HTML/JavaScript/SVG, including node creation, parent-child relationships, and dynamic branching. Check if it supports multi-level nesting (at least 5 levels deep) and proper node positioning algorithms. Score 0 if basic tree structure is missing, 5 if only 2-3 levels are supported, and 10 if full hierarchical functionality with proper algorithms is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are interactive editing features comprehensively implemented?",
+      "description": "Evaluate whether the implementation includes essential mind map operations: adding/deleting nodes, editing text content, dragging to reorganize structure, and keyboard shortcuts support. Check for real-time content saving and undo/redo functionality. Deduct 3 points if drag-and-drop is not smooth, 5 points if keyboard navigation is missing, and 2 points if text editing has no auto-save. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the visual rendering engine optimized and scalable?",
+      "description": "Check whether the rendering system uses efficient algorithms for large datasets (1000+ nodes), implements proper viewport culling, and supports smooth zoom/pan operations. Evaluate if it uses canvas/SVG optimization techniques and maintains 60fps during interactions. Deduct 5 points if performance drops with 100+ nodes, 3 points if zoom operations are laggy, and 5 points if no viewport optimization exists. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are data export and import capabilities properly implemented?",
+      "description": "Verify whether the system supports multiple export formats (JSON, XML, image formats like PNG/SVG) and can import standard mind map formats. Check if the data structure preserves all visual and structural information during export/import cycles. Deduct 4 points if only one export format is supported, 3 points if imported data loses styling information, and 3 points if export images have quality issues. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid input data, browser compatibility issues, memory leaks during long usage, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases like empty nodes, circular references, and malformed import data, 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. AI-powered topic suggestions 2. Collaborative real-time editing 3. Smart auto-layout algorithms 4. Integration with external knowledge bases 5. Advanced search and filtering). 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 layout algorithms doing the same thing) 2. Function modules unrelated to mind mapping (e.g., built-in games or unrelated widgets) 3. Fancy effects that affect performance (e.g., excessive animations or particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if 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 data model/view/controller layers), code organization, and maintainability. Check for proper separation of concerns, consistent coding style, and documentation quality. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if the code structure is chaotic with poor maintainability. 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 mind map UX principles: 1) Harmonious color scheme with proper contrast for nodes 2) Consistent visual hierarchy and spacing (following 8px grid system) 3) Professional typography (readable fonts, proper sizes ≥ 12px) 4) Intuitive iconography and visual cues. Deduct 3 points for each visually crowded element, 5 points for poor color accessibility, and 5 points for inconsistent visual language. 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) Node creation/deletion with smooth transitions 2) Hover states with immediate feedback (≤ 100ms) 3) Pan and zoom operations feel natural and responsive 4) Connection lines animate smoothly during restructuring 5) Loading states are properly handled. Deduct 5 points for each operation without visual feedback, 3 points for jerky animations, and 5 points for unresponsive interactive elements. Full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Mermaid Flowcharts-Mind Maps",
+  "difficulty": "hard"
+}