@getollie/cli 0.0.1

package/library/utility_tools-automation/python-pinduoduo-automation-gui.json

@@ -0,0 +1,68 @@
+{
+  "index": 901,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Note that you should ensure the code you generate is executable and can be demonstrated. I work in e-commerce, specifically on the Pinduoduo platform. I want to write Python code that meets the following requirements: When run, it opens an interface that includes various automated work functions for the platform, such as automatically posting links, adding comments, and other operations. You can add any additional automation features you think would be useful. The code should be able to automatically recognize and perform operations. This might be challenging, but I believe you are definitely capable of accomplishing this.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the automated operation core functionality fully implemented?",
+      "description": "Review whether the code accurately implements core automation features including link posting, comment adding, and other e-commerce operations through Python automation libraries (selenium, pyautogui, etc.). Check if element recognition, click simulation, text input, and form submission are properly handled. Score 0 if core automation logic is not implemented, 5 if only basic operations are implemented, and 10 if comprehensive automation workflows are fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the platform recognition and adaptation mechanism implemented?",
+      "description": "Check whether the code includes robust web element detection, page loading verification, and platform-specific UI adaptation. Evaluate if the system can handle dynamic content loading, CAPTCHA detection, and anti-bot measures. Deduct 5 points if element selectors are hardcoded without fallback, and 3 points if page state verification is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the user interface design intuitive and functional?",
+      "description": "Evaluate whether the GUI interface (tkinter/PyQt) provides clear function categorization, real-time operation status display, and easy-to-use controls for automation tasks. Check if progress indicators, log displays, and configuration panels are implemented. Deduct 5 points if the interface lacks operation feedback, and 3 points if function grouping is unclear. Give 10 points if fully implemented with professional layout.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is comprehensive task scheduling and batch processing constructed?",
+      "description": "Check whether the code includes complete task queue management, scheduled execution, batch operation capabilities, and task persistence. Evaluate if the system supports task prioritization, retry mechanisms, and operation history tracking. Deduct 5 points if batch processing is not implemented, and 3 points if task scheduling lacks error recovery. Give 10 points if fully implemented with advanced scheduling features.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network timeouts, element not found, platform updates, session expiration, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance productivity (e.g., 1. Smart content generation with AI 2. Performance analytics and reporting 3. Multi-account management 4. Intelligent scheduling based on platform activity). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar automation functions (e.g., multiple browser control methods coexisting) 2. Function modules unrelated to e-commerce automation (e.g., built-in games or media players) 3. Resource-intensive features that affect performance (e.g., unnecessary video recording of all operations). Deduct 3 points for each redundancy found, and directly deduct 10 points if core automation 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 automation logic/GUI/configuration layers), error logging implementation, 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 configuration is hardcoded without external config files. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the GUI design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (consistent padding and margins) 3) Professional typography (readable font sizes ≥ 12px, consistent font family). Deduct 3 points for each crowded visual element, 5 points for poor color contrast or clashing combinations, and 5 points for inconsistent styling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the automation interaction smooth and reliable?",
+      "description": "Judge whether the automation operations conform to human-like behavior patterns: 1) Random delays between actions (100-500ms) 2) Smooth cursor movements and natural click patterns 3) Proper wait conditions for page elements 4) Clear operation status feedback in real-time. Deduct 5 points for each robotic behavior pattern, 3 points for insufficient wait conditions causing failures, and 5 points for lack of operation progress indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/react-custom-templates-json-output.json

@@ -0,0 +1,68 @@
+{
+  "index": 1358,
+  "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. Requirement: React, support for custom templates, with JSON output.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the React component structure properly implemented?",
+      "description": "Review whether the code establishes a clean component hierarchy with proper separation of concerns. Check for functional components using hooks (useState, useEffect, useMemo, etc.) instead of class components where appropriate. Assess if props are properly typed and documented. Score 0 if component structure is missing or severely flawed, 5 if basic components exist but with structural issues, and 10 if components follow React best practices with clear hierarchies and proper state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the template customization system fully functional?",
+      "description": "Evaluate whether the code implements a flexible template system that allows users to define, save, and apply custom templates. Check for template component inheritance, slot mechanisms, or higher-order components that facilitate customization. Verify if the system includes template selection UI, preview capabilities, and the ability to modify template properties. Deduct 5 points if templates cannot be saved or reused, and 3 points if customization options are too limited. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the JSON output functionality correctly implemented?",
+      "description": "Assess whether the code properly serializes data to JSON format, validates JSON structure before output, and handles edge cases like circular references. Check if the JSON output is properly formatted, includes necessary metadata, and can be parsed back into the application. Deduct 5 points if JSON validation is missing, and 3 points if the output format is inconsistent. Verify that complex data types are correctly serialized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is state management appropriate for the application scale?",
+      "description": "Examine whether the state management solution (Context API, Redux, Recoil, etc.) matches the application's complexity. For simpler applications, local state should be sufficient; more complex ones should utilize global state management. Check for proper state normalization, immutability practices, and performance optimizations like memoization. Deduct 5 points if global state is overused for simple scenarios, and 3 points if state updates cause unnecessary re-renders. 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 inputs, network errors, failed template loading, etc.) and provide friendly error boundaries or recovery mechanisms. Code with strong robustness should include proper error handling, input validation, and fallback UI components. Give 10 points for comprehensive error handling strategies, 5 points if basic error handling exists but with gaps, and 0 points if exceptions are not handled.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Live template preview with real-time updates 2. AI-assisted template generation 3. Collaborative template editing 4. Version control for templates). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant state management solutions coexisting 2. Unnecessary re-rendering of components 3. Over-engineered features that complicate the application without adding value. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core template and JSON functionality are obscured by unnecessary code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI components, custom hooks, and business logic), test coverage, and build process optimization. Deduct 5 points if component responsibilities are unclear; deduct 5 points if the codebase lacks unit tests or testing utilities; deduct 5 points if no performance optimizations are implemented (such as code splitting, lazy loading). 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 React UI principles: 1) Consistent component styling (preferably using CSS-in-JS or CSS Modules) 2) Responsive design that works across device sizes 3) Accessible UI with proper ARIA attributes and keyboard navigation. Deduct 3 points for inconsistent styling, 5 points for non-responsive layouts, and 5 points for accessibility violations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the React application provides smooth user interactions: 1) Immediate feedback for user actions 2) Smooth transitions between states using animations or micro-interactions 3) Optimized rendering performance with no jank. Deduct 5 points for laggy UI updates, 3 points for missing loading states during asynchronous operations, and 5 points for form submissions without validation feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "easy"
+}

package/library/utility_tools-automation/ruoyi-framework-code-generator.json

@@ -0,0 +1,68 @@
+{
+  "index": 983,
+  "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. I want to build my own code generator based on the RuoYi framework.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the RuoYi framework architecture correctly understood and explained?",
+      "description": "Check if the response accurately explains RuoYi's multi-tier architecture (controller-service-dao layers), module structure, and core components like Spring Boot integration, MyBatis configurations, and security frameworks. Score 0 if there's no understanding of RuoYi's architecture, 5 if only basic components are mentioned, and 10 if there's a comprehensive explanation including module relationships and dependency management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the code generation mechanism fully implemented?",
+      "description": "Evaluate whether the code generator implementation includes template parsing, database metadata extraction, and customizable output configurations. Essential features include entity-relationship mapping, multi-database support, and preserving custom code during regeneration. Deduct 5 points if only basic CRUD generation is supported without customization options; deduct 3 points if the generator doesn't maintain custom code regions when regenerating. Full score requires intelligent field type mapping and annotation handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the template customization capabilities comprehensive?",
+      "description": "Review the template engine implementation, checking for velocity/freemarker integration, variable injection mechanisms, and template inheritance structures. Verify if the solution allows developers to define custom templates for different output formats (Java/Vue/React) and supports conditional code generation. Deduct 5 points if template customization isn't supported; deduct 3 points if only basic variable substitution is available without conditional logic.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a user-friendly interface for code generation configuration?",
+      "description": "Assess whether the solution provides a visual interface for selecting tables, configuring field properties, setting generation options, and previewing generated code. Check for batch generation capabilities and configuration saving/loading features. Score 0 if no UI is provided, 5 if there's a basic form interface, and 10 if there's a comprehensive UI with real-time preview and configuration management.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid database connections, malformed table structures, permission issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-assisted code suggestions 2. Code quality metrics integration 3. Intelligent database relationship detection 4. Interactive preview with live data). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple template engines doing the same job) 2. Function modules unrelated to code generation (e.g., built-in media players) 3. Fancy effects that affect performance (e.g., excessive animations in the UI). 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 template engine/database access/file output), 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/task-scheduler-with-notifications-and-javascript-execution.json

@@ -0,0 +1,68 @@
+{
+  "index": 652,
+  "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 whenever possible. Develop a task scheduler that allows the creation of multiple scheduled tasks (such as daily 9:00 AM reminders, hourly time announcements, etc.). When a task is due, display notifications in the system notification center and execute custom JavaScript code snippets (like location.reload()).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core task scheduling mechanism properly implemented?",
+      "description": "Check if the implementation correctly handles time-based scheduling with precision for different intervals (hourly, daily, weekly, etc.). Verify that the scheduler maintains accurate timing even during long periods of operation. Score 0 if core scheduling logic is missing, 5 if basic timing works but lacks precision for all intervals, and 10 if all scheduling patterns work with accurate timing.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the notification system correctly integrated?",
+      "description": "Evaluate whether the code properly uses the Notification API or an equivalent system. Check if it handles notification permissions correctly, with fallbacks for denied permissions. Verify that notifications contain relevant task information and provide user interaction options. Deduct 5 points if notification permissions aren't properly requested, 3 points if notifications lack customization options, and 2 points if there are no fallbacks for browsers without notification support.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the code safely execute custom JavaScript snippets?",
+      "description": "Review how the system handles execution of custom code snippets. Check for sandboxing methods or security measures to prevent dangerous code execution. Verify error handling for failed script execution. Deduct 7 points if there's no validation or sandboxing of user input code, 5 points if error handling is inadequate, and 3 points if the execution environment doesn't isolate code properly.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete task management interface?",
+      "description": "Assess the task creation, editing, and deletion functionality. Check if the interface allows setting various schedule types (one-time, recurring), provides task listing/filtering, and includes status indicators. Deduct 5 points if task CRUD operations are incomplete, 3 points if recurring options are limited, and 2 points if the task listing lacks organization features or search capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser tab closing, sleep mode, connection issues, etc.) and provide recovery mechanisms. Check for race conditions in the timing system and task queue management. 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. Natural language task creation 2. Task categorization and priority system 3. Visual timeline of scheduled tasks 4. Integration with calendar services). 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 timing functions (e.g., multiple timer mechanisms coexisting) 2. Function modules unrelated to task scheduling (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., complex animations during notifications). 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 timing logic/UI/notification systems), 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) Task creation feedback delay ≤ 100ms 2) Notification animations controlled between 300-500ms 3) Clear visual indication of active and upcoming tasks. Deduct 5 points for each operation without feedback, 3 points for notifications that interrupt user workflow unnecessarily, 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/tauri-react-shadcn-tailwind-auto-update-project.json

@@ -0,0 +1,68 @@
+{
+  "index": 1074,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Help me create a project using Tauri, React, Shadcn, and Tailwind.css with auto-update functionality.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Tauri application architecture correctly implemented?",
+      "description": "Review whether the code properly configures Tauri with React integration, including correct tauri.conf.json setup, proper Rust backend commands, and IPC (Inter-Process Communication) between frontend and backend. Check if the build process generates functional native executables for target platforms. Score 0 if Tauri core functionality is missing, 5 if basic setup exists but lacks proper IPC, and 10 if fully functional with secure command invocations and proper error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the React + Shadcn + Tailwind integration properly configured?",
+      "description": "Evaluate whether React components utilize Shadcn UI components effectively with proper Tailwind CSS styling. Check for correct package.json dependencies, proper component imports, and theme configuration. Verify that Tailwind classes are purged correctly and Shadcn components render with consistent styling. Deduct 3 points if component library integration is incomplete, 5 points if styling conflicts exist, and 2 points if build optimization is missing. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the auto-update functionality fully implemented and secure?",
+      "description": "Check whether the auto-update mechanism includes proper version checking, secure download verification (signature validation), and graceful update installation. Evaluate if the updater handles network failures, provides user notifications, and supports rollback mechanisms. Verify that update endpoints are configured correctly and SSL/TLS is enforced. Deduct 5 points if signature verification is missing, 3 points if no fallback mechanism exists, and 5 points if update UI feedback is inadequate. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the project structure and configuration management comprehensive?",
+      "description": "Assess whether the project includes proper environment configuration, build scripts for multiple platforms, and deployment workflows. Check for proper TypeScript configuration, ESLint/Prettier setup, and development/production environment separation. Verify that all necessary configuration files (vite.config.js, tailwind.config.js, components.json) are properly set up. Deduct 3 points for missing TypeScript support, 4 points for inadequate build configuration, and 3 points for missing development tooling. 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 during updates, file system permissions errors, invalid user input, and Tauri API failures) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include proper error boundaries, async error handling, and graceful degradation. Give 10 points if fully implemented, 5 points if basic error handling exists, and 0 points if no exception handling is present.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the Tauri application experience (e.g., 1. System tray integration with context menus 2. Native notifications and system integration 3. Custom window controls and themes 4. Local database integration 5. Cross-platform native file handling). Add 2-3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple state management solutions coexisting) 2. Unnecessary dependencies that bloat the bundle size 3. Over-engineered components that don't utilize Tauri's native capabilities effectively. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code significantly impacts application performance or bundle size.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (proper separation of Tauri commands, React components, and utility functions), TypeScript type safety, and automated build processes. Check for proper component composition, custom hooks usage, and build optimization. Deduct 5 points if TypeScript types are poorly defined; deduct 5 points if component architecture is monolithic; deduct 5 points if build process lacks platform-specific optimizations. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional standards?",
+      "description": "Evaluate whether the UI follows modern design principles using Shadcn components effectively: 1) Consistent design system with proper Tailwind utility usage 2) Proper spacing using Tailwind's spacing scale 3) Accessible color contrast ratios and focus states 4) Responsive design that works across different screen sizes. Deduct 3 points for inconsistent component usage, 5 points for poor color accessibility, and 5 points for non-responsive layouts. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the native desktop interaction smooth and intuitive?",
+      "description": "Judge whether the desktop application provides native-like user experience: 1) Proper window management and native controls 2) Keyboard shortcuts and accessibility support 3) Smooth transitions utilizing Tauri's performance benefits 4) Native context menus and system integration. Deduct 5 points for web-like behavior that doesn't leverage native capabilities, 3 points for poor keyboard navigation, and 5 points for lack of system integration features. Full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

package/library/utility_tools-automation/user-agent-switcher-with-presets-and-detection.json

@@ -0,0 +1,68 @@
+{
+  "index": 563,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable whenever possible. Implement a User-Agent switcher that provides presets for common devices (iOS/Android/PC), supports custom UA strings, and can detect the current page's UA for quick testing and switching.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the UA switcher core functionality fully implemented?",
+      "description": "Check if the code provides a complete UA switcher that can modify the User-Agent string in the browser. It should include functionality to get the current UA, set a new UA, and restore the original UA. Score 0 if the core functionality is missing, 5 if basic switching is implemented but with limitations, and 10 if the implementation is complete with all required features.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are presets for common devices (iOS/Android/PC) properly implemented?",
+      "description": "Verify that the code includes accurate and up-to-date UA string presets for common device types (at least iOS, Android, and PC/Desktop browsers). Each preset should contain the correct string format for the respective platform and major browser versions. Deduct 3 points if any major platform is missing, 2 points if the UA strings are outdated, and 2 points if the preset selection UI is not intuitive. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is custom UA string input functionality properly implemented?",
+      "description": "Assess whether users can input, save, and apply custom UA strings. The interface should validate input to ensure it's a valid UA string format, provide feedback on application success, and maintain a history of custom entries. Deduct 3 points if validation is missing, 3 points if there's no persistence mechanism, and 2 points if the UI for custom input is confusing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is current page UA detection and quick switching implemented?",
+      "description": "Evaluate if the code can detect and display the current page's UA string, and provide a mechanism for quickly switching between different UAs without requiring page reload. Check if the detection works across different browsing contexts and if the switching is instantaneous. Deduct 5 points if detection only works on the initial page load, and 5 points if switching requires a page reload. 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 browser API restrictions, permission issues, incompatible browsers, 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. UA comparison visualization 2. Device emulation preview 3. Analytics for website behavior under different UAs). 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 methods to change UA) 2. Function modules unrelated to UA switching (e.g., a built-in screenshot tool) 3. Fancy effects that affect performance (e.g., unnecessary animations when switching). 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 UA management/UI/storage layers), browser compatibility considerations, and code organization. Deduct 5 points if global namespace 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 proper error handling or logging. 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) UA switching feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual indication of active UA. Deduct 5 points for each operation without feedback, 3 points for jarring transitions when switching UAs, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

package/library/utility_tools-automation/video-camera-detection-line-crossing-counting.json

@@ -0,0 +1,68 @@
+{
+  "index": 1005,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable. Disregard sections 4.4 and 4.5, and write out the software page display based on the following content:\n\n1) Video Detection Demonstration\n1. Click the open video icon to choose a video for detection, and the detection results will be displayed automatically. Clicking this button again will close the video.\n2. After opening the video, click \"Draw Line Segment\" and use the left mouse button to click two points on the displayed interface to draw a line segment for counting objects crossing the line.\n3. After completing the two points, click the \"Complete Drawing\" button to enable bi-directional counting and statistics of objects crossing the line in the video.\nNote: The \"Detection Duration\" displayed on the interface indicates the length of video time that has been detected [related to detection speed], not the actual elapsed time.\n\n(2) Camera Detection Demonstration\n1. Click the open camera icon to activate the camera for real-time detection. Clicking this button again will close the camera.\n2. After opening the camera, click \"Draw Line Segment\" and use the left mouse button to click two points on the displayed interface to draw a line segment for counting objects crossing the line.\n3. After completing the two points, click the \"Complete Drawing\" button to enable bi-directional counting and statistics of objects crossing the line in the video.\nNote: The \"Detection Duration\" displayed on the interface indicates the length of video time that has been detected [related to detection speed], not the actual elapsed time.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the video detection function fully implemented?",
+      "description": "Review whether the code correctly implements video file selection, loading, and automatic detection. Check if the video playback controls work properly and if the detection results are displayed in real-time. Score 0 if the video detection is not implemented, 5 if basic video loading works but detection has issues, and 10 if video detection functions flawlessly with proper error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the camera detection function properly implemented?",
+      "description": "Evaluate if the code successfully accesses the device camera, handles permissions correctly, and processes the camera feed for detection. Check whether the camera can be turned on/off as specified and if detection works in real-time. Deduct 5 points if camera permissions are not properly handled, and 3 points if there are performance issues with real-time detection. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the line segment drawing functionality implemented correctly?",
+      "description": "Check if users can draw a line segment by clicking two points on the interface, and if the 'Draw Line Segment' and 'Complete Drawing' buttons work as specified. Verify that the line remains visible after drawing and maintains its position during video playback. Deduct 5 points if the drawing mechanism is buggy, and 3 points if the visual feedback is unclear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the object crossing detection and bi-directional counting implemented accurately?",
+      "description": "Verify if the code correctly detects and counts objects crossing the drawn line in both directions. Check the accuracy of the counting algorithm (intersection detection) and whether the statistics are updated in real-time. Score 0 if counting is not implemented, 5 if basic counting works but has accuracy issues, and 10 if bi-directional counting is fully functional with high precision.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid video files, camera access denial, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Object type filtering 2. Heatmap visualization of crossing patterns 3. Exportable detection statistics with timestamps). 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 draw detection lines) 2. Function modules unrelated to video/camera detection (e.g., unnecessary settings pages) 3. Fancy effects that affect detection performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core detection 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 detection logic/UI/data processing layers), code reusability between video and camera detection modules, and performance optimization. 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 performance optimization for real-time detection. 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) Clear visual indicators for detection results and statistics. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for unclear visualization of detection results. 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) Detection results appear without noticeable delay 2) Line drawing feedback is immediate and precise 3) Clear visual indicators when objects cross the line. Deduct 5 points for laggy detection visualization, 3 points for imprecise drawing feedback, and 5 points for unclear crossing indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

package/library/utility_tools-automation/video-download-tool-with-batch-and-quality-options.json

@@ -0,0 +1,68 @@
+{
+  "index": 509,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the generated code is executable for demonstration. Develop a video download tool where users can input video URLs (such as YouTube), and the tool will automatically parse and provide different quality options for video download, supporting batch downloading and progress display.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the URL parsing and video metadata extraction fully implemented?",
+      "description": "Review whether the code accurately parses various video platform URLs (YouTube, Vimeo, etc.) and correctly extracts metadata including available quality options, video length, and format information. Score 0 if parsing is not implemented, 5 if only basic YouTube parsing works, and 10 if the system handles multiple platforms and extracts complete metadata.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the quality selection mechanism properly implemented?",
+      "description": "Check whether users can select from different quality options (resolution, bitrate, format) for each video. The interface should display size estimates for each option and preview thumbnails if possible. Deduct 3 points if only preset quality options are available, 5 points if quality comparison is missing, and 7 points if format conversion options are absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the batch download functionality effectively implemented?",
+      "description": "Evaluate whether the code allows users to queue multiple videos for download, with features like priority adjustment, pause/resume for individual downloads, and batch operations. Check if there's intelligent queue management for bandwidth optimization. Deduct 5 points if parallel download limits aren't configurable, and 3 points if download reordering is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the progress display and notification system comprehensive?",
+      "description": "Review whether the progress tracking includes detailed information (download speed, ETA, file size), visual indicators (progress bars with percentage), and system notifications (completion alerts, error messages). Deduct 3 points for missing speed indicators, 3 points for inaccurate ETA calculations, and 5 points if there's no persistent progress tracking after browser refresh. 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 URLs, network interruptions, server-side restrictions, rate limiting, 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. Smart format detection based on device 2. Auto-categorization of downloaded content 3. Integration with media players for preview). 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 download methods 2. Function modules unrelated to video downloading (e.g., a built-in video editor) 3. Fancy effects that affect performance (e.g., excessive animations during downloads). 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 parsing/downloading/UI layers), unit test coverage, and error handling. 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 proper logging system for debugging purposes. 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 during download operations. Deduct 5 points for each operation without feedback, 3 points for jerky progress animations, and 5 points for hard-to-find download control buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "easy"
+}