@getollie/cli 0.0.1

package/library/utility_tools-automation/ethernet-packet-capture-vue2-electron-app.json

@@ -0,0 +1,68 @@
+{
+  "index": 1618,
+  "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. Create a local Ethernet packet capture software using Vue 2.0 and package it into a desktop application with Electron.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the packet capture functionality fully implemented?",
+      "description": "Review whether the code correctly implements core packet capture functionality using appropriate libraries (like libpcap/npcap/node-pcap) with Vue 2.0. Check if it captures packet headers and payloads, performs protocol analysis, and allows filtering of packets. Score 0 if core capture logic is absent, 5 if basic capture works but lacks protocol analysis, and 10 if it fully implements capture with comprehensive protocol decoding (TCP/IP, HTTP, DNS, etc.).",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Electron integration complete for system-level operations?",
+      "description": "Evaluate if the codebase properly implements Electron's IPC mechanism for communication between renderer and main processes, particularly for accessing system network interfaces which require elevated privileges. Check for proper permissions handling, native module bindings, and system tray integration. Deduct 5 points if raw socket access isn't properly implemented, 3 points if security permissions aren't handled correctly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the Vue 2.0 architecture implemented according to best practices?",
+      "description": "Check if the Vue architecture follows component-based design with proper state management (Vuex), routing (vue-router), and lifecycle hooks. Evaluate component reusability and proper separation of concerns. Deduct 5 points if global state management is missing or incorrectly implemented, 3 points if component design is monolithic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is real-time packet visualization and analysis provided?",
+      "description": "Assess whether the application provides real-time packet visualization (charts, graphs, traffic flow diagrams) with appropriate refresh rates. Check if statistical analysis tools are available (bandwidth usage, protocol distribution, connection tracking). Deduct 5 points if visualization updates are delayed (>1s latency), and 3 points if analysis features are minimal. Full score requires both comprehensive visualization and analysis capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as permission denials, network adapter failures, high traffic volumes, 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. Automated security threat detection 2. Packet replay functionality 3. Network topology visualization 4. Protocol-specific decoders for application layer protocols). 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 packet filtering systems) 2. Function modules unrelated to packet capture (e.g., built-in media player) 3. Fancy effects that affect capture performance (e.g., excessive animations during packet capture). 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 capture logic/UI/analysis modules), 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 Electron packaging process is not automated or optimized. 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 packet display layouts. 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 during high packet capture rates. Deduct 5 points for each operation without feedback, 3 points for UI freezes during high traffic capture, and 5 points for hard-to-find filtering or analysis functions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/excel-group-assignment-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 1734,
+  "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. Write an HTML code that can randomly assign people from an uploaded Excel file into groups, allowing selection of the number of people per group, while balancing gender and department distribution. The groups should be displayed on the page after completion, with a button to export the results to Excel. The Excel workbook contains a sheet with \"Name,\" \"Gender,\" and \"Department\" data.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Excel file upload and parsing functionality properly implemented?",
+      "description": "Check if the code uses reliable libraries (like SheetJS/xlsx) to handle Excel file parsing. Verify that file validation is implemented (file type check, size limit). Verify error handling for malformed Excel files. Score 0 if file upload is missing, 5 if basic upload works but lacks validation, and 10 if robust upload with proper error handling is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the group assignment algorithm properly implemented with balanced distribution?",
+      "description": "Evaluate if the algorithm effectively balances gender and department distribution across groups. Check if it handles edge cases (uneven distribution possibilities, empty cells). The algorithm should use statistical methods to ensure fairness. Deduct 5 points if only simple random assignment is implemented, 3 points if either gender or department balancing is missing, and give 10 points if sophisticated balancing with optimization logic is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the group size selection interface properly implemented?",
+      "description": "Check if users can select the number of people per group through an intuitive interface. Verify validation for input values (minimum/maximum constraints based on total participants). The interface should provide real-time feedback on how many groups will be created. Deduct 3 points if validation is missing, 5 points if there's no feedback on resulting group count, and give 10 points for a complete implementation with validation and feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the group result display and Excel export functionality properly implemented?",
+      "description": "Verify that grouped results are clearly displayed on the page with visual separation between groups. Check if the export to Excel functionality works correctly, maintaining the grouping structure in the exported file. Deduct 5 points if export doesn't maintain proper formatting, 3 points if visual display is confusing, and give 10 points for clear display with proper Excel export functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid Excel files, unexpected data formats, empty fields, 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. Visualization of gender/department distribution per group 2. Drag-and-drop manual adjustments after auto-grouping 3. Group naming or color-coding options). 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 parsing methods) 2. Function modules unrelated to group assignment (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., complex animations that slow down the page). 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/UI/export functionality), code organization, and maintainability. 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 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 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 processing, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "easy"
+}

package/library/utility_tools-automation/export-multiple-html-to-pdf-with-jspdf-react-tss.json

@@ -0,0 +1,68 @@
+{
+  "index": 849,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable. Implement a solution in React+TSS to export multiple HTML codes to PDF, setting an HTML template for the PDF while preserving CSS styles. The method should allow HTML with different parameters but the same framework to use the same export method. Do not use canvas drawing. Use jspdf - please provide a demo.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the PDF export functionality correctly implemented with jsPDF?",
+      "description": "Evaluate whether the solution correctly uses jsPDF library for HTML-to-PDF conversion without relying on canvas drawing. Check if the implementation includes proper initialization of jsPDF, handles page breaks appropriately, and correctly renders HTML content to PDF. Score 0 if jsPDF is not implemented, 5 if basic implementation exists but with limitations, and 10 if full HTML-to-PDF conversion works smoothly.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is CSS style preservation properly handled in the PDF export?",
+      "description": "Verify that the solution correctly preserves CSS styles when exporting HTML to PDF. Check if it handles complex CSS properties (flexbox, grid, media queries, etc.), custom fonts, and responsive designs. Deduct 3 points if basic styles are preserved but complex layouts break, 5 points if fonts or specific CSS properties aren't supported, and 10 points if no CSS preservation is implemented. Full score of 10 requires demonstration of preserving various CSS properties.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the HTML templating system flexible and reusable?",
+      "description": "Assess whether the solution implements a flexible HTML template system that can be used with different parameters. Check if the template system allows for dynamic content insertion, conditional rendering, and maintains the same structure across different data inputs. Deduct 3 points if templates are hardcoded, 5 points if templates have limited customization capability, and 8 points if templates cannot handle different data structures. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the solution provide a unified export method for different HTML content?",
+      "description": "Examine if the implementation offers a single, unified export method that works effectively with different HTML content but the same framework. Check for parameterization, abstraction level, and reusability of the export function. Deduct 3 points if separate export methods are needed for different HTML structures, 5 points if significant code modification is needed between exports, and 8 points if the method doesn't handle edge cases like large content or special characters. Full score requires a robust, unified export approach.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed HTML, excessive content length, special characters, image loading failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Preview functionality before export 2. Progress indicator during PDF generation 3. Batch export capability 4. Custom header/footer options). 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 PDF generation methods coexisting) 2. Function modules unrelated to PDF export (e.g., unnecessary image processing) 3. Fancy effects that affect performance (e.g., excessive animations during export). 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 PDF generation logic/template rendering/styling), TypeScript type safety, and React best practices. Deduct 5 points if global state pollution is found or TypeScript types are poorly implemented; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if React hooks are improperly used causing performance issues. 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) Export operation feedback ≤ 500ms 2) Loading indicators for lengthy operations 3) Clear visual guidance for export process. Deduct 5 points for each operation without feedback, 3 points for unresponsive UI during PDF generation, and 5 points for hard-to-find export function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "easy"
+}

package/library/utility_tools-automation/food-delivery-robot-mini-program-joystick-controls.json

@@ -0,0 +1,68 @@
+{
+  "index": 1268,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable if possible. Context: Food delivery robot project architecture: Frontend using uniapp vue3 js, API: Django, database: Django's built-in SQLite, MQTT service, ROS1. Requirements: Phone remote control sends MQTT messages, MQTT to JS, JS sends ROSJS to the robot's ROS1. Functionality needed: A mini-program compatible with both tablets and phones featuring smooth joystick controls for the robot vehicle.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the joystick control interface fully implemented?",
+      "description": "Review whether the code accurately implements a touchscreen joystick with HTML5/JavaScript, including touch event handling, movement range limitations, auto-centering, and haptic feedback. Score 0 if the core interaction is missing, 5 if basic movement is implemented but lacks responsive design, and 10 if the joystick works flawlessly across different screen sizes with proper touch and drag events.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the MQTT communication layer properly implemented?",
+      "description": "Check if the code includes MQTT client implementation with proper connection handling, topic subscription/publishing, QoS settings, and reconnection mechanisms. Verify that MQTT messages are properly formatted for robot control commands (velocity, direction, etc.). Deduct 5 points if there's no reconnection handling, 3 points if there's no connection status indication, and 3 points if message encoding/serialization is inefficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the ROSJS bridge implementation complete?",
+      "description": "Evaluate whether the code properly implements roslibjs to communicate with ROS1, including WebSocket connection setup, topic publishing/subscription handling, service calls, and action client implementations. Check for proper error handling when ROS connection fails. Deduct 5 points if the implementation lacks connection state management, 3 points if it doesn't handle message type conversions properly, and 3 points if it doesn't include fallback mechanisms. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the Django API and database integration effectively designed?",
+      "description": "Assess whether the Django backend properly integrates with the frontend, including RESTful API endpoints for robot status/control, authentication mechanisms, and database models for storing robot states, user preferences, and operational logs. Check if the API includes proper validation, rate limiting, and error responses. Deduct 5 points if there's no authentication, 3 points if database models are poorly designed, and 3 points if the API lacks comprehensive documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruption, MQTT broker unavailability, ROS disconnection, device orientation changes, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Visual robot path preview 2. Battery level indicators with predictive alerts 3. Obstacle detection visualization 4. Motion gesture controls as joystick alternatives). 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 control mechanisms (e.g., multiple joystick libraries combined) 2. Function modules unrelated to robot control (e.g., unnecessary social sharing features) 3. Fancy effects that affect performance (e.g., excessive animations that impact responsiveness). 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 control logic/UI/communication layers), unit test coverage, and build process automation. Examine uniapp component organization, Vue3 composition API usage, and code splitting strategies. 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) 4) Adaptive layouts for both tablet and phone form factors. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for failing to properly adapt between tablet and phone layouts. 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 control latency ≤ 50ms 2) Robot response visualization updates at ≥30fps 3) Clear visual feedback for connection status changes. Measure actual touch-to-movement latency in the control system. Deduct 5 points for each operation without feedback, 3 points for joystick stuttering during fast movements, and 5 points for control commands that execute with >200ms delay. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/google-extension-vue-devtools-vue2-vue3.json

@@ -0,0 +1,68 @@
+{
+  "index": 717,
+  "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 displayable. Help me write a Google extension: the requirement is similar to the Vue DevTools in the Google Store, and it should simultaneously support both Vue 2 and Vue 3.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Chrome extension architecture correctly implemented?",
+      "description": "Evaluate whether the extension follows Chrome extension best practices with proper manifest.json configuration (v3 preferred), background scripts, content scripts, and popup interfaces. Check for permission declarations, extension lifecycle management, and proper isolation between contexts. Score 0 if basic extension structure is missing, 5 if implementation is basic but functional, 10 if implementation is comprehensive and follows all Chrome extension guidelines.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the extension properly detect both Vue 2 and Vue 3 applications?",
+      "description": "Review the detection mechanism for identifying Vue instances in the page. Check if it can distinguish between Vue 2 and Vue 3, adapt to different mounting patterns, and handle both options API and composition API. Examine how it handles multiple Vue instances on the same page. Deduct 5 points if detection works for only one Vue version, 3 points if edge cases (like lazy-loaded components) aren't handled. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the component tree visualization fully implemented?",
+      "description": "Check if the extension properly builds and displays the component hierarchy tree with correct parent-child relationships. Verify if it updates in real-time when components mount/unmount, and shows component depth levels correctly. Assess whether the tree is searchable and filterable. Score 0 if visualization is absent, 5 if basic tree is implemented but lacks features, 10 if complete with all expected functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are component inspection features comparable to Vue DevTools?",
+      "description": "Evaluate the component inspection functionality: props viewing/editing, data observation, computed properties calculation, methods listing, and event tracking. Check support for time-travel debugging and state snapshots. Verify hooks/lifecycle visualization for both Vue versions. Deduct 3 points for each major missing feature compared to official DevTools. 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 pages with multiple Vue instances, hydration mismatches, minified production builds, SSR applications, 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. Component rendering performance metrics 2. State change diff visualization 3. Component export/import 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 ways to inspect the same property) 2. Function modules unrelated to Vue debugging (e.g., general DOM inspection that duplicates Chrome DevTools) 3. Fancy effects that affect performance (e.g., excessive animations in the panel). 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 core logic/UI/communication 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 sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/image-based-search-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 1343,
+  "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 for demonstration. Help me create a small program for image-based search.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image loading and processing functionality properly implemented?",
+      "description": "Evaluate if the code correctly handles image loading (from file upload or URL), preprocessing (resizing, normalization), and error handling for corrupt or invalid images. Score 0 if image handling is missing, 5 if basic loading works but lacks preprocessing, and 10 if it includes comprehensive image manipulation with proper error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the image feature extraction algorithm well-implemented?",
+      "description": "Check whether the code implements proper feature extraction techniques (e.g., color histograms, SIFT, HOG features, or deep learning embeddings). Assess algorithm selection appropriateness for image search. Deduct 5 points if only basic pixel comparison is used, 3 points if advanced features are implemented but inefficiently. Give full 10 points for optimized, industry-standard feature extraction.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there an efficient image matching/similarity calculation mechanism?",
+      "description": "Evaluate the implementation of similarity metrics (e.g., cosine similarity, Euclidean distance) and optimization techniques for fast comparison. Check if indexing is used for large datasets. Deduct 5 points if brute-force comparison is used on large datasets, 3 points if metrics are implemented but without optimization. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a well-designed search results display and user interface?",
+      "description": "Assess if the search results are clearly displayed with relevant information (similarity score, metadata), pagination if needed, and sorting options. Check for interactive previews and result filtering capabilities. Deduct 5 points for basic list display without visual thumbnails, 3 points if results lack metadata or sorting. Give 10 points for comprehensive, user-friendly result presentation.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid images, network failures, memory constraints with large datasets, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time visual feedback during search 2. Content-based filtering options 3. Interactive image editing before search). 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 image processing functions 2. Feature modules unrelated to image search (e.g., a built-in social media sharing system) 3. Computationally expensive visualizations that affect 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 image processing/feature extraction/search/UI 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 image display techniques (proper thumbnails, responsive galleries). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for poor image rendering quality. 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) Search feedback delay ≤ 500ms or progress indicator for longer searches 2) Smooth transitions when displaying results 3) Clear visual guidance during the image upload and search process. Deduct 5 points for searches without progress indication, 3 points for jerky transitions between search states, and 5 points for unintuitive image upload interfaces. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "easy"
+}

package/library/utility_tools-automation/implement-automatic-backup-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 650,
+  "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 when possible. Implement an automatic backup tool that allows users to select data they need to back up (such as notes, task lists, etc.), and regularly save the data to local or cloud storage, providing recovery and version management functions.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the backup source selection mechanism properly implemented?",
+      "description": "Evaluate whether the code implements a flexible selection mechanism that allows users to choose specific data types (notes, tasks, etc.) or files for backup, with proper file system permissions handling. Score 0 if selection functionality is missing, 5 if basic file selection is implemented, and 10 if the implementation includes advanced features like wildcards, exclusion rules, and metadata-based filtering.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the backup scheduling system fully functional?",
+      "description": "Check whether the tool implements configurable backup scheduling with options for frequency (hourly, daily, weekly), specific times, and event-triggered backups. Deduct 3 points if the scheduling is hardcoded, 5 points if it lacks persistence across system restarts, and 5 points if it doesn't handle missed backup windows. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the backup storage mechanism properly designed?",
+      "description": "Assess whether the tool provides both local and cloud storage options with proper authentication, encryption, and storage optimization. Check for incremental backup capability to save space and bandwidth. Deduct 5 points if only one storage type is supported, 3 points if data is not encrypted, and 3 points if no compression or deduplication is implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are version management and recovery features comprehensive?",
+      "description": "Evaluate whether the tool implements a clear version history, point-in-time recovery capabilities, and efficient version pruning mechanisms. Check for features like version browsing, comparison, and selective restoration. Deduct 5 points if only full restores are possible, 3 points if version metadata is incomplete, and 5 points if there's no conflict resolution for multi-device scenarios. 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 failures, permission issues, storage limitations, corrupted backups, 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. AI-powered selective backup suggestions 2. Cross-device sync capabilities 3. Content-aware backup prioritization). 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 backup methods 2. Function modules unrelated to data backup/recovery (e.g., a built-in media player) 3. Fancy effects that affect performance (e.g., unnecessary animations during backup). 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 backup logic/UI/storage 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) Backup progress indicators with accurate time estimation 2) Non-blocking UI during backup operations 3) Clear visual feedback for completed/failed backups. Deduct 5 points for operations without feedback, 3 points for UI freezes during backups, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/implement-fabricjs-mobile-h5-application.json

@@ -0,0 +1,68 @@
+{
+  "index": 1635,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable and presentable when possible. Functional goal: Implement a mobile H5 application based on Fabric.js JSON data for template replacement. Users only need to upload images, text, prices, and other content, and use Fabric.js to generate images for user download. The application should include canvas controls such as layer adjustment, font color, etc.\n\nTechnology stack: Vue3 + wot-design-uni component library.\nSpecial requirements: Mobile adaptation, embedded in a mini program.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Fabric.js template replacement system fully implemented?",
+      "description": "Review whether the code accurately implements the Fabric.js template system with proper loading/parsing of JSON templates and handling of object replacements (images, text, prices). Score 0 if the core template replacement is not implemented, 5 if basic replacement works but has limitations, and 10 if the system handles all replacement types with proper validation and error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the canvas editing controls comprehensive and functional?",
+      "description": "Evaluate the implementation of canvas controls including layer adjustment, font styling (color, size, family), object positioning, scaling, and rotation. Deduct 2 points for each missing essential control (layer management, text editing, image manipulation). The implementation should use Fabric.js APIs correctly and maintain object states properly. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the mobile adaptation properly implemented?",
+      "description": "Check whether the application is properly adapted for mobile devices with responsive canvas sizing, touch interactions (pinch zoom, drag, etc.), and appropriate UI scaling. Verify that the canvas maintains proper aspect ratios across different screen sizes. Deduct 5 points if the canvas is not responsive, 3 points if touch gestures are not properly handled. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the mini-program embedding integration fully functional?",
+      "description": "Assess the integration with mini-program environments, including proper handling of context, lifecycle hooks, and platform-specific APIs. Check if the application handles permissions correctly (file system access, image picking) and manages state persistence within the mini-program context. Deduct 5 points if platform-specific adaptations are missing, 3 points if there are compatibility 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 JSON templates, failed image loading, network interruptions, memory constraints on mobile devices) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should 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 preview while editing 2. One-click social sharing with custom thumbnails 3. Smart object alignment guides). 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 image upload methods coexisting) 2. Function modules unrelated to the template editing (e.g., unnecessary animations) 3. Resource-heavy features that affect mobile 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 Fabric.js canvas logic from Vue components), component reusability, and build process optimization for mini-program environments. Deduct 5 points if global state management is poorly implemented; deduct 5 points if the code doesn't follow Vue 3 composition API best practices; deduct 5 points if there's no performance optimization for mobile devices. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the UI follows the wot-design-uni design system consistently: 1) Proper component usage without custom overrides that break design consistency 2) Mobile-first layout with appropriate touch targets (minimum 44×44px) 3) Professional typography system respecting the component library's defaults. Deduct 3 points for each UI inconsistency, 5 points for poor information hierarchy, and 5 points for illegible text on mobile screens. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects are optimized for mobile: 1) Canvas rendering maintains 60fps during manipulation 2) Image loading and processing includes loading states and optimization 3) Clear visual indicators during export/download process. Deduct 5 points for each interaction with noticeable lag, 3 points for missing loading indicators, and 5 points for unresponsive UI during heavy operations like image processing. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}