@getollie/cli 0.0.5 → 0.2.1

package/library/utility_tools-automation/monorepo-vue3-vite-tailwind-v4-setup.json

@@ -1,68 +0,0 @@
-{
-  "index": 354,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be careful to ensure that the generated code is executable and can be demonstrated. In a monorepo Vue3 Vite Tailwind V4 project, sub-projects in the apps directory and common components stored in the components directory under packages/core can all use Tailwind V4.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the monorepo structure correctly configured for Vue3, Vite, and Tailwind v4?",
-      "description": "Review the project structure to ensure it follows best practices for a monorepo with proper directory organization (apps directory for sub-projects, packages/core for common components). Check if package.json contains correct workspaces configuration, and if the root configuration properly references all workspace packages. Score 0 if the basic structure is incorrect, 5 if structure exists but with configuration issues, 10 if perfectly organized.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are Vite configurations properly set up across the monorepo?",
-      "description": "Examine if vite.config.js/ts files are properly configured at both root and sub-project levels with correct aliases, build options, and plugins. Check if path resolution works correctly between packages. Verify that each sub-project can independently build and run. Deduct 5 points if build dependencies are incorrectly configured, and 3 points if hot module replacement doesn't work across packages. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is Tailwind v4 correctly integrated across all packages and apps?",
-      "description": "Verify that tailwind.config.js is properly configured at the root level and/or in each sub-project with correct content paths. Check if Tailwind directives (@tailwind base, components, utilities) are properly imported in main CSS files. Verify that utility classes work in both apps and shared components. Deduct 5 points if there are conflicting configurations, deduct 3 points if custom theme values aren't properly shared. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are shared components in packages/core accessible and styled correctly across sub-projects?",
-      "description": "Check if components in packages/core are properly exported and can be imported in apps. Verify that Tailwind classes are applied correctly in shared components and maintain consistent styling across different sub-projects. Ensure component props are properly typed with TypeScript. Deduct 5 points for component import issues, deduct 3 points for inconsistent styling behavior. 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 missing props, network interruptions, component loading errors, etc.) and provide friendly error prompts or fallbacks. Code with strong robustness should show error boundaries in Vue components, defensive coding patterns, and proper error handling. Give 10 points for comprehensive error handling, 5 points for basic error handling, and 0 points if no error handling exists.",
-      "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 development experience (e.g., 1. Custom Vite plugins for the monorepo 2. Shared state management solution across apps 3. Automated component documentation). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Duplicate dependencies across packages (e.g., multiple versions of Vue) 2. Redundant configuration files (e.g., multiple ESLint configs with similar rules) 3. Unnecessary build steps that slow down development. Deduct 3 points for each redundancy found, and directly deduct 10 points if core functionality is compromised by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as proper separation of concerns in components), TypeScript usage quality, test coverage, and CI/CD configuration. Deduct 5 points if global state is used inappropriately; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no automated tests. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Consistent use of Tailwind utility classes following the design system 2) Proper spacing and layout (using Tailwind's spacing scale consistently) 3) Professional typography (using appropriate text sizes and line heights from the Tailwind config). Deduct 3 points for inconsistent spacing, 5 points for accessibility issues (contrast, focus states), and 5 points for chaotic responsive layouts. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the Vue components provide smooth interaction: 1) Proper use of transitions and animations 2) Optimized rendering with proper use of v-memo, shallowRef, etc. 3) Efficient loading strategies (lazy loading where appropriate). Deduct 5 points for jank during interactions, 3 points for memory leaks from improper cleanup, and 5 points for poor performance when navigating between sub-apps. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "medium"
-}

package/library/utility_tools-automation/multi-window-typescript-framework-no-vue.json

@@ -1,68 +0,0 @@
-{
-  "index": 1078,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate, professional responses. Be careful to ensure that any code you generate is executable. I want to build a multi-window framework in TypeScript, without using Vue.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Does the multi-window framework implement a complete window management system?",
-      "description": "Review whether the code implements the basic components of a window system: window creation, positioning, resizing, maximizing, minimizing, closing, and z-index management. Score 0 if window creation and manipulation are not implemented, 5 if only basic operations are available, and 10 if all standard window behaviors (including snapping, restoring state) are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is window state management properly implemented?",
-      "description": "Evaluate the implementation of window state tracking and persistence. Check for a centralized state management system that handles window positions, sizes, visibility, focus state, and stacking order. Look for proper event handling and state transitions. Deduct 3 points if window states are not properly persisted, 3 points if focus management is incorrect, and 4 points if state transitions are buggy or inconsistent.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the framework provide flexible content rendering and communication between windows?",
-      "description": "Check if the framework allows dynamic content loading within windows and implements inter-window communication. Test if windows can exchange messages, share data, or access common services. Award full points if both iframe support and a messaging API are implemented with proper type safety. Deduct 5 points if windows are isolated with no communication mechanism, and 3 points if the communication is poorly typed or unreliable.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the TypeScript implementation well-typed and does it leverage TypeScript's features effectively?",
-      "description": "Review the TypeScript implementation for proper typing, interfaces/types for window configurations, proper use of generics, and type safety across the framework. Evaluate if the code leverages TypeScript features like discriminated unions, mapped types, or conditional types where appropriate. Deduct 5 points for any use of 'any' type, 3 points for insufficient interfaces/types, and 2 points for not using TypeScript features that would improve the code.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid window configurations, DOM manipulation errors, event race conditions, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should prevent window states from becoming corrupted and handle edge cases like rapid window operations or browser limitations. Give 10 points for comprehensive error handling, 5 points for basic error handling, and 0 points if exceptions are not managed.",
-      "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. Window grouping or tabbing 2. Window templates with predefined behaviors 3. Animated transitions between window states 4. Window theming system). 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 functionality (e.g., multiple window management systems) 2. Unnecessary abstractions that complicate the codebase 3. Performance-heavy features that aren't essential to window management (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if core window functions are negatively impacted by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating core functionality, UI rendering, event handling), test coverage, and build process. Check for proper dependency management, code organization, and documentation. Deduct 5 points if global state is poorly managed; deduct 5 points if code duplication rate is high (over 30%); deduct 5 points if there's no build configuration or it's inadequate. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the window design follows modern UI principles: 1) Consistent window chrome design (title bars, borders, controls) 2) Proper spacing and alignment of window elements 3) Professional and accessible controls with proper sizing and hover states. Deduct 3 points for inconsistent window styling, 5 points for poor accessibility in window controls, and 5 points for awkward or unnatural window behaviors. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the window interaction smooth and responsive?",
-      "description": "Judge whether window operations feel natural and responsive: 1) Window creation/closing animations under 300ms 2) Dragging/resizing with no perceptible lag 3) Proper cursor feedback during window operations. Deduct 5 points for jittery window movement, 3 points for slow or delayed responses to user input, and 5 points for any operation that freezes the UI for more than 100ms. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "medium"
-}

package/library/utility_tools-automation/network-packet-capture-analysis-tool.json

@@ -1,68 +0,0 @@
-{
-  "index": 570,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Develop a network packet capture and analysis tool that can capture HTTP/HTTPS requests and responses in the browser, displaying information such as request headers, response bodies, and time consumption. Support filtering requests by URL, status code, content type, and other conditions, and allow exporting captured data in HAR format. Provide request replay and editing functionality.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the network packet capture mechanism fully implemented?",
-      "description": "Review whether the code accurately implements HTTP/HTTPS request interception using browser APIs (such as chrome.webRequest, Service Worker, or browser DevTools Protocol). Check if it includes complete capture of request/response headers, body content, timing information, and WebSocket connections. Score 0 if core capture functionality is missing, 5 if only basic HTTP requests are captured, and 10 if comprehensive packet capture including HTTPS, redirects, and error responses is fully implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the real-time analysis and display system implemented?",
-      "description": "Evaluate whether the implementation includes real-time parsing and display of captured packets with detailed information (headers, payload, timing, size). Check for proper handling of different content types (JSON, XML, images, etc.) and encoding formats. Deduct 5 points if response body parsing is incomplete, and 3 points if timing analysis lacks precision. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are comprehensive filtering and search capabilities provided?",
-      "description": "Check whether the filtering system supports multiple criteria including URL patterns, HTTP methods, status codes, content types, request size, and custom header values. Evaluate if advanced search features like regex matching and boolean operators are implemented. Deduct 5 points if filtering is limited to basic criteria only, and 3 points if search performance is poor with large datasets. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are HAR export and request replay functions fully constructed?",
-      "description": "Verify whether the code includes complete HAR (HTTP Archive) format export functionality with proper JSON structure and all required fields. Check if request replay and editing features allow modification of headers, parameters, and body content with validation. Deduct 5 points if HAR export is incomplete or invalid, and 5 points if replay functionality lacks proper error handling. Give 10 points if fully implemented with import/export capabilities.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed requests, large payloads, network timeouts, browser permission denials, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases including memory management for large captures. Give 10 points for comprehensive error handling, 5 points if robustness is average, and 0 points if no exceptions are 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 analysis experience (e.g., 1. Real-time network performance metrics and visualization 2. Automatic API documentation generation from captured requests 3. Request diff comparison tools 4. Security vulnerability detection). 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 capture mechanisms (e.g., multiple packet capture libraries coexisting) 2. Function modules unrelated to network analysis (e.g., built-in text editor with full IDE features) 3. Excessive visual effects that impact performance (e.g., real-time 3D network topology animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if core analysis 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 engine/analysis logic/UI layers), memory management for large datasets, and performance optimization. Deduct 5 points if memory leaks are found or inefficient data structures are used; deduct 5 points if the code lacks proper architecture patterns; deduct 5 points if there's no consideration for handling high-volume traffic. 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 for developer tools: 1) Harmonious color coding for different HTTP methods and status codes 2) Proper layout with collapsible panels and efficient space usage 3) Professional monospace fonts for code display and proper syntax highlighting. Deduct 3 points for each cluttered data visualization, 5 points for poor color contrast affecting readability, and 5 points for chaotic information hierarchy. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the interface handles real-time data updates efficiently: 1) Live packet capture display without UI freezing 2) Smooth scrolling through large datasets with virtualization 3) Responsive filtering and search with debounced input 4) Quick access to detailed packet information. Deduct 5 points for each laggy interaction during high-traffic capture, 3 points for delayed search results, and 5 points for unresponsive UI during data processing. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "hard"
-}

package/library/utility_tools-automation/photoshop-2025-one-click-photo-cutout-jsx-script.json

@@ -1,68 +0,0 @@
-{
-  "index": 1161,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Create a JSX script for one-click photo cutout in Photoshop 2025.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the JSX script structure and Photoshop API integration correctly implemented?",
-      "description": "Review whether the JSX script properly uses Photoshop's ExtendScript API, includes correct app.activeDocument references, and implements proper layer manipulation methods. Check if the script handles document validation, layer creation, and selection operations according to Photoshop 2025 specifications. Score 0 if basic Photoshop objects are not accessed, 5 if only simple operations work, and 10 if all core Photoshop APIs are properly integrated with error handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the automated cutout algorithm implementation effective and accurate?",
-      "description": "Evaluate whether the script implements intelligent subject detection using Photoshop's built-in AI features (like 'Select Subject' or 'Remove Background'), includes edge refinement algorithms, and handles complex backgrounds. Check if the script uses proper selection methods like colorRange(), contract(), expand(), and feather() for precise cutouts. Deduct 5 points if edge detection is poor, 3 points if transparency handling is incomplete. Full score requires advanced selection refinement and multi-layer support.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the one-click workflow optimization properly designed with batch processing capability?",
-      "description": "Check whether the script provides true one-click functionality with minimal user intervention, includes batch processing for multiple images, and implements proper file handling (open, save, export). Evaluate if the script supports different input formats, automatic output naming conventions, and progress tracking. Deduct 5 points if manual intervention is required for each image, 3 points if batch processing fails on different file types. Full score requires seamless automation with robust file management.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is comprehensive user preference and output format management implemented?",
-      "description": "Assess whether the script includes user-configurable settings (output format, quality, transparency options), supports multiple export formats (PNG, PSD, TIFF), and provides preview functionality before final processing. Check if the script remembers user preferences, includes undo functionality, and handles different color modes. Deduct 5 points if only basic PNG export is supported, 3 points if no user customization options exist. Full score requires complete preference management and format flexibility.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as locked layers, no active document, unsupported file formats, memory limitations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include try-catch blocks, proper error logging, and graceful degradation. Give 10 points if fully robust, 5 points if basic error handling exists, and 0 points if no exception handling is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that enhance the cutout workflow?",
-      "description": "Check whether the code includes advanced features that improve the cutout experience (e.g., 1. Hair/fur detail preservation algorithms 2. Smart background replacement suggestions 3. Automatic edge color correction 4. Batch watermark removal 5. AI-powered subject recognition training). Add 3 points for each practical innovative feature implemented that goes beyond basic cutout functionality (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant selection methods (e.g., multiple similar cutout algorithms running simultaneously) 2. Unrelated image editing features (e.g., built-in filters or artistic effects) 3. Performance-heavy operations that don't improve cutout quality (e.g., unnecessary high-resolution previews). Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code significantly impacts script performance or core functionality.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separating selection logic, file handling, and UI components), proper function organization, and code maintainability. Check for consistent naming conventions, adequate commenting, and reusable function structures. Deduct 5 points if global variable pollution is found or no modular pattern is used; deduct 5 points if code duplication rate exceeds 30%; deduct 5 points if functions are not properly documented or organized. Full score requires clean, maintainable architecture.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the user interface (if implemented) meet professional design standards?",
-      "description": "If the script includes a UI panel, evaluate whether it follows Adobe's design guidelines: 1) Consistent with Photoshop's native UI styling 2) Proper spacing and alignment (following 4px grid system) 3) Clear button hierarchy and iconography 4) Appropriate color scheme matching Photoshop's theme. Deduct 3 points for each UI element that doesn't match Adobe standards, 5 points for poor visual hierarchy, and 5 points for confusing layout. Full score for native-looking, intuitive interface.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the script performance optimized and processing feedback clear?",
-      "description": "Judge whether the script provides clear processing feedback: 1) Progress indicators during cutout operations 2) Processing time optimization for large files 3) Memory usage management 4) Clear status messages and completion notifications. Deduct 5 points for each operation without user feedback, 3 points if processing hangs on large files without indication, and 5 points if memory usage is not optimized. Full score requires smooth performance with comprehensive user feedback throughout the process.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "hard"
-}

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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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"
-}