@getollie/cli 0.0.1

package/library/utility_tools-automation/vs2019-code-generation-tools-requirements.json

@@ -0,0 +1,68 @@
+{
+  "index": 1395,
+  "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 and can be demonstrated. What tools can work with you that directly integrate with VS2019, where I describe requirements and it writes code for me?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is there a comprehensive analysis of VS2019 compatible AI coding tools?",
+      "description": "Evaluate whether the response provides a thorough overview of available AI coding assistants that integrate with Visual Studio 2019. The analysis should cover both Microsoft's first-party tools and third-party extensions. Deduct 3 points if major tools are missing, 5 points if integration methods aren't explained. Full implementation scores 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is there a technical comparison of the capabilities of different AI coding tools?",
+      "description": "Check if the response compares the technical capabilities of different tools (language support, code generation capabilities, context understanding, etc.). A complete comparison should include feature matrices, supported programming languages, and limitations. Deduct 5 points if only surface-level comparison is provided without technical depth. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are practical installation and configuration instructions provided?",
+      "description": "Assess whether the response includes step-by-step instructions for installing and configuring these tools in VS2019, including screenshots of the installation process, environment requirements, and potential conflicts. Deduct 5 points if only general instructions are provided without VS2019-specific details. Full implementation scores 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are there concrete examples demonstrating the tools in action?",
+      "description": "Evaluate whether the response includes practical examples/screenshots showing how to use the tools to generate code from requirements in different scenarios (e.g., UI components, algorithms, database operations). Deduct 3 points for each major programming paradigm not covered. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether any sample code provided demonstrates error handling, input validation, and follows best practices for the respective languages. Code with strong robustness should handle edge cases and include appropriate comments explaining complex logic. Give 10 points for excellent robustness, 5 points for average implementation, and 0 points if no error handling is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the response highlights unique capabilities of the tools that might not be immediately obvious (e.g., refactoring suggestions, architecture planning, automated testing). Add 3 points for each practical innovative feature highlighted (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check for redundancy in the response: 1. Overlapping tool recommendations without differentiation 2. Explanation of features unrelated to VS2019 integration 3. Excessive theoretical explanations without practical application. Deduct 3 points for each redundancy found, and directly deduct 10 points if core information is obscured by redundant content.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the response have engineering quality?",
+      "description": "Review the organization of information, accuracy of technical details, and overall structure of the response. Deduct 5 points if information is poorly organized; deduct 5 points if technical specifications contain errors; deduct 5 points if the response lacks logical progression. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional documentation standards?",
+      "description": "Evaluate whether any screenshots and diagrams are clear, properly annotated, and follow professional documentation standards. Check for logical organization of visual elements, proper resolution, and highlighting of important UI elements. Deduct 3 points for each unclear visual element, 5 points for poor labeling, and 5 points for inconsistent visual style. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the practical workflow guidance provided?",
+      "description": "Judge whether the response provides a clear workflow for using these tools effectively: 1) Requirement formulation guidelines 2) Tool selection criteria based on project needs 3) Iterative refinement process with the AI. Deduct 5 points for missing workflow stages, 3 points for vague instructions, and 5 points for unrealistic expectations about tool capabilities. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

package/library/utility_tools-automation/vue-desktop-app-browser-plugin-settings.json

@@ -0,0 +1,68 @@
+{
+  "index": 310,
+  "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 display purposes. Please create a Vue desktop application with browser management, plugin management, and settings menu. When clicking on browser management, it should display a paginated view with 10 items per page, showing workid and operation columns. The workid is an auto-incrementing ID starting from 1. Operations include start and stop buttons. Clicking start will launch Chrome.exe from a specified path with startup parameters:\n\n```javascript\nconst args = [\n    `--lang=zh-CN`,\n    `--timezone=${timezone || 'Asia/Hong_Kong'}`,\n    `--fps=${workId}`,\n    // `--window-icon=${iconPath}`,\n];\nconst allExtensions = [...(pluginPaths || [])];\nif (allExtensions.length > 0) {\n    args.push('--load-extension=' + allExtensions.join(','));\n    args.push('--disable-extensions-except=' + allExtensions.join(','));\n}\n```\n(This is what I wrote in JavaScript)",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Vue desktop application structure correctly implemented?",
+      "description": "Review whether the code properly implements a Vue desktop application with the three required main components: browser management, plugin management, and settings menu. Check if Vue.js framework is correctly set up with proper component structure, routing, and state management. Score 0 if the core structure is missing, 5 if implemented but with architectural issues, and 10 if properly structured with component reusability and clean architecture.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the browser management functionality fully implemented?",
+      "description": "Verify if the browser management component correctly displays a paginated view with 10 items per page, showing workid and operation columns as required. Check if the auto-incrementing workid starting from 1 is properly implemented. Deduct 5 points if pagination is incorrect or missing, 3 points if workid implementation is flawed, and 3 points if the display layout is poorly structured. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the start and stop operations correctly implemented in the browser management?",
+      "description": "Evaluate whether clicking the start button properly launches Chrome.exe with the specified parameters (language, timezone, fps, extensions) and whether the stop button correctly terminates the process. Check if the code handles process management properly. Deduct 5 points if Chrome launching fails with specified parameters, 3 points if process termination is not properly handled, and 3 points if error handling for these operations is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the plugin management functionality properly implemented?",
+      "description": "Assess whether the plugin management section allows users to add, view, and manage Chrome extensions that will be used in the '--load-extension' and '--disable-extensions-except' parameters. Check if the UI allows browsing for extension paths and if the selected extensions are properly stored and used when launching Chrome. Deduct 5 points if extension path selection is missing, 3 points if validation is inadequate, and 3 points if the extension list management is poorly implemented. 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 Chrome paths, missing extensions, process launch failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Browser profile management 2. Extension marketplace integration 3. Performance monitoring dashboard for launched browsers). 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 launch browsers) 2. Function modules unrelated to browser management (e.g., built-in games) 3. Fancy effects that affect performance (e.g., unnecessary animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI components/business logic/process management layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 877,
+  "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. Rewrite a complete Vue packet capture project that can be packaged into an Electron desktop application.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the packet capturing functionality fully implemented?",
+      "description": "Review whether the code accurately implements the core packet capture functionality using appropriate libraries (like pcap, npcap, or libpcap bindings). Check if it can capture different protocols (TCP, UDP, HTTP, etc.), filter packets by protocol/IP/port, and display packet details. Score 0 if core capture functionality is missing, 5 if basic capturing works but with limited protocol support, and 10 if comprehensive protocol analysis is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Vue frontend properly structured and integrated with Electron?",
+      "description": "Evaluate the Vue project structure, component organization, and proper integration with Electron. Check for proper use of Vue's reactivity system, component lifecycle management, and appropriate use of Vuex/Pinia for state management. Examine whether the build process correctly bundles the application for Electron. Deduct 5 points if Vue-Electron integration has security issues, and 3 points if the build process is incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are packet visualization and analysis features implemented?",
+      "description": "Check if the application provides visual representations of captured packets (charts, timelines, flow diagrams) and analysis tools (filters, search, statistics). Verify if packet details can be exported in standard formats (PCAP, CSV, JSON). Deduct 5 points if visualization is basic or missing, 3 points if analysis tools are limited. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper handling of system permissions and native OS integration?",
+      "description": "Assess whether the application correctly requests and manages elevated permissions required for packet capture across different operating systems. Check for proper error handling when permissions are denied, and verify appropriate use of native OS APIs through Electron. Deduct 5 points if permission handling is incomplete, and 3 points if the application fails on specific operating systems. 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 permission denial, network interface changes, high packet volume, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time protocol anomaly detection 2. Machine learning based traffic classification 3. Customizable dashboard with drag-and-drop widgets 4. Built-in packet replay functionality). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple packet filtering mechanisms) 2. Function modules unrelated to packet capture (e.g., a built-in media player) 3. Fancy effects that affect performance (e.g., excessive animations that slow down packet processing). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating capture logic/visualization/analysis layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast packet display updates, 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/vue3-webpack-complete-process.json

@@ -0,0 +1,68 @@
+{
+  "index": 1323,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to make the code you generate executable for demonstration. Vue3 webpack complete process",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Vue3 project initialization and webpack configuration fully implemented?",
+      "description": "Review whether the code accurately sets up a Vue3 project with webpack, including proper configuration files (webpack.config.js), development and production modes, and essential loaders. Score 0 if the basic webpack configuration is missing, 5 if only basic configuration is implemented, and 10 if it includes optimized configurations for both development and production environments.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the Vue3 core features properly integrated with webpack?",
+      "description": "Check whether the configuration properly handles Vue3's Composition API, Single File Components (.vue files), and script setup syntax. The webpack configuration should include vue-loader with proper options. Deduct 5 points if SFC handling is incorrectly configured, and 3 points if Composition API features aren't supported. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is asset handling and optimization properly implemented?",
+      "description": "Evaluate whether the webpack configuration includes proper loaders and plugins for different asset types (CSS, SCSS, images, fonts, etc.), along with optimization strategies like minification, code splitting, and tree shaking. Deduct 5 points if asset loaders are missing or misconfigured, and 3 points if no optimization techniques are implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the development environment properly configured?",
+      "description": "Check whether the code includes proper development tools like webpack-dev-server with hot module replacement, source maps for debugging, and environment variables management. Deduct 5 points if hot reloading isn't implemented, and 3 points if proper debugging tools are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common build errors (such as import errors, syntax errors in Vue files, etc.) and provide friendly error messages or recovery mechanisms. Code with strong robustness should include proper error plugins and fallbacks, giving 10 points. If the robustness is average, give 5 points, and if no error handling is implemented, 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 development experience (e.g., 1. Build analytics visualization 2. Custom webpack plugins for Vue-specific optimizations 3. Automatic component documentation generation). 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 webpack plugins performing similar tasks 2. Unnecessary transpilation steps or polyfills 3. Over-engineered configurations that add complexity without benefits. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core build process is slowed down significantly by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular configuration design (separating webpack configs by environment), proper dependency management (dev vs. prod dependencies), and build process automation. Deduct 5 points if configurations are not modularized; deduct 5 points if there's excessive duplication between configs; deduct 5 points if the build process isn't properly scripted in package.json. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the project structure follow Vue3 best practices?",
+      "description": "Evaluate whether the project structure follows modern Vue3 standards: 1) Proper separation of components, composables, and views 2) Consistent naming conventions for files and directories 3) Clear organization of assets and styles. Deduct 3 points for unclear component organization, 5 points for mixing concerns (like API calls in components), and 5 points for inconsistent file structures. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the build performance and output optimized?",
+      "description": "Judge whether the build process is optimized for performance: 1) Proper code splitting and lazy loading 2) Cache optimization with contenthash 3) Minimized bundle size with tree shaking and proper external dependencies. Deduct 5 points for missing code splitting, 3 points for inefficient caching strategies, and 5 points for bloated bundle sizes without optimization. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

package/library/utility_tools-automation/web-mouse-auto-clicker-with-left-right-buttons.json

@@ -0,0 +1,68 @@
+{
+  "index": 1808,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. Can you help me write a mouse auto-clicker that can be opened on a web page and simulates physical mouse clicks for both left and right buttons?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the auto-clicker core functionality properly implemented?",
+      "description": "Check if the code correctly implements the primary auto-clicking functionality including both left and right mouse clicks. Verify that it allows selecting click type (left/right), setting click interval, and provides start/stop controls. Score 0 if clicking functionality is missing, 5 if only left clicks are implemented, and 10 if both left and right clicks work correctly.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the click interval configuration robust and flexible?",
+      "description": "Evaluate if the code allows precise control over click intervals (milliseconds between clicks). Check for input validation, minimum/maximum bounds, and whether it handles decimals correctly. Verify that changing the interval works during operation without requiring restart. Deduct 3 points if validation is missing, 3 points if changing interval requires restart, 5 points if interval precision is poor (>50ms error).",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a proper click target selection mechanism?",
+      "description": "Review whether the auto-clicker provides a way to select specific targets on the page rather than just clicking at the current cursor position. Check for target selection methods like coordinate input, element selection, or visual targeting system. Score 0 if no targeting is available, 5 if only fixed coordinates work, and 10 if dynamic target selection (e.g., element-based) is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are there click pattern options beyond simple repeated clicks?",
+      "description": "Check if the code offers advanced clicking patterns like sequences (click patterns), random intervals, bursts (multiple clicks followed by pause), or custom patterns. Score 0 if only fixed-interval clicking is available, 5 if basic patterns exist, and 10 if multiple sophisticated patterns are implemented with configuration options.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser tab switching, memory limitations, rapid setting changes, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Click heat map visualization 2. Keyboard shortcut controls 3. Click sound effects with volume control). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple timer implementations) 2. Function modules unrelated to auto-clicking (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., excessive DOM operations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI logic from clicking mechanism), error handling, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no memory management for long-running operations. 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 operation changes, 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/webpage-screenshot-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 529,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure that the generated code is executable for demonstration.\n\n======== Role ========\nYou are an experienced code expert. I am providing you with a software development requirement description and ask you to generate project code based on these requirements. Strictly follow the rules to help users generate complete project code with simple and understandable comments, without outputting anything else.\n\n======== Output Rules ========\n1. You should always generate complete, runnable code for the project, making sure the project is fully executable\n2. Ensure that all code files you output are complete, without omitting any code\n3. Before final output, carefully review and check all code to evaluate its executability. If the code cannot execute or contains errors, regenerate it\n4. If the requirements involve external API access or require user data (images, videos, audio, etc.), please provide mock data\n\n======== Project Requirements ========\nDevelop a webpage screenshot tool where users can input a URL and the tool automatically captures either a full-page screenshot or a specified area. The tool should support different screenshot sizes, and users should be able to download the captured images.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the URL input and screenshot capture functionality fully implemented?",
+      "description": "Check whether the code correctly implements the URL input field and screenshot capture mechanism. Verify if both full-page and specified area screenshots work properly. Score 0 if the core capture functionality isn't implemented, 5 if only basic capture is available, 10 if both full-page and area selection options are fully functional with proper error handling for invalid URLs.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the area selection feature properly implemented?",
+      "description": "Evaluate if the area selection tool allows users to accurately define regions for screenshot capturing. Check if it includes resizable selection rectangles, precise coordinate tracking, and handles edge cases (like selections outside the viewport). Deduct 3 points if selection isn't visually indicated, 5 points if resize/move functionality is missing, and 5 points if the coordinates aren't properly captured. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the tool support different screenshot sizes and formats?",
+      "description": "Review if the tool provides options for different screenshot resolutions (e.g., desktop, mobile, custom dimensions) and multiple export formats (PNG, JPEG, etc.). Verify if dimension changes properly affect the viewport/output. Deduct 3 points if only one resolution is supported, 3 points if only one format is available, and 4 points if custom dimensions aren't offered. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the download functionality properly implemented?",
+      "description": "Check if screenshot images can be properly downloaded with appropriate filenames, formats, and quality settings. Verify that download works across major browsers and includes progress indicators for large screenshots. Deduct 5 points if download doesn't work on at least two major browsers, 3 points if filename customization is missing, and 2 points if there's no progress indicator for large captures. 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, CORS issues, timeout errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Image editing tools after capture 2. OCR text extraction from screenshots 3. Auto-scroll capture for long pages 4. Delayed capture with countdown). 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 screenshot functions 2. Function modules unrelated to screenshot capture (e.g., unnecessary social sharing) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core screenshot functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating capture logic, UI components, and download functionality), error handling practices, 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 no performance considerations exist for large page captures. 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 feedback during screenshot capture process. Deduct 5 points for each operation without feedback, 3 points for lack of loading indicators during capture, 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-batch_processing/batch-image-retouching-with-parameters.json

@@ -0,0 +1,68 @@
+{
+  "index": 974,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you provide is executable. Prioritize using Meitu's pre-signed URL solution, and only switch to third-party storage if stability issues arise.\n\nI would like to implement something similar. Please provide detailed code for a program that opens with an interface containing adjustable beauty parameters. After setting the parameters and clicking \"Start Retouching,\" the software will monitor a specified folder, automatically process any incoming images using the preset retouching parameters, and then export them to a designated output folder.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the user interface for beauty parameter adjustment fully implemented?",
+      "description": "Review whether the code implements an intuitive UI with clearly labeled sliders/controls for beauty parameters (like smoothing, whitening, slimming, eye enlargement, etc.). Check if parameter ranges are appropriate with reasonable defaults. Score 0 if there's no UI implementation, 5 if only basic controls exist without proper organization, and 10 if a comprehensive, well-designed parameter adjustment panel is provided with visual previews of effects.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the folder monitoring system properly implemented?",
+      "description": "Evaluate the implementation of the directory watcher that detects new image files. Check if it uses proper file system events (rather than polling), handles various edge cases (partially written files, temporary files, non-image files), and manages system resources efficiently. Deduct 5 points if monitoring is unstable or uses excessive polling, and 3 points if it doesn't handle edge cases properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the image processing pipeline correctly implemented with Meitu's pre-signed URL solution?",
+      "description": "Check whether the code properly integrates with Meitu's pre-signed URL API for image processing, including authentication, parameter formatting, and error handling. Verify that the solution correctly constructs API requests with beauty parameters and processes responses. Deduct 5 points if the implementation doesn't use Meitu's solution as primary, and 10 points if there's no proper error handling or fallback mechanism. Full score of 10 points requires complete implementation with proper documentation.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the automatic batch processing workflow complete?",
+      "description": "Evaluate if the code includes a complete workflow from detecting new images to processing and saving them in the output folder. Check for proper threading/async processing to prevent UI freezing, progress indicators, and logging of successes/failures. Score 10 if the system handles batches efficiently with proper concurrency controls, 5 if basic functionality exists but with synchronous blocking operations, and 0 if the workflow is incomplete.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network failures, invalid images, disk full errors, 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. Real-time preview of effects 2. Preset templates for different scenarios 3. Batch processing statistics and reports). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple image loading paths) 2. Function modules unrelated to the core requirements (e.g., built-in social media sharing) 3. Fancy effects that affect performance (e.g., unnecessary animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/image processing/file system modules), error handling, logging, and configuration management. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if configuration is hardcoded. 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) Parameter adjustment reflects changes instantly or with appropriate visual feedback 2) Processing status clearly visible with progress indicators 3) Clear visual distinction between processed and unprocessed images. Deduct 5 points for each operation without feedback, 3 points for laggy parameter adjustments, and 5 points for unclear processing status. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Batch Processing",
+  "difficulty": "medium"
+}

package/library/utility_tools-batch_processing/code-expert-drag-drop-table-display.json

@@ -0,0 +1,68 @@
+{
+  "index": 788,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional replies. Make sure the code you produce is executable and demonstrable. You can drag and drop folders or multiple files, the functionality remains unchanged, and display the results in table format.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the code properly structured for file/folder handling?",
+      "description": "Evaluate whether the code implements proper detection and handling of both individual files and folder structures. Check if it recursively traverses directories when needed and correctly preserves folder hierarchies. Score 0 if basic file handling is missing, 5 if only single file handling is implemented, and 10 if complete folder structure handling with proper error cases is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is drag and drop functionality properly implemented?",
+      "description": "Assess whether the code correctly implements HTML5 drag and drop API with proper event handling (dragenter, dragover, dragleave, drop). Check if it prevents default browser behaviors, provides visual feedback during drag operations, and handles multiple file selections. Deduct 5 points if drag highlighting is missing, 3 points if it doesn't handle browser compatibility issues. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is file processing and data extraction handled efficiently?",
+      "description": "Review how the code extracts and processes data from various file types. Check if it uses appropriate APIs (FileReader, Blob, etc.), handles large files efficiently (e.g., streaming for large files), and properly sanitizes input data. Deduct 5 points if it lacks progress indicators for large files, 3 points if memory management for large datasets is poor. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the table display functionality properly implemented?",
+      "description": "Evaluate whether the code effectively presents data in a well-structured table format with proper styling and layout. Check for sorting capabilities, pagination for large datasets, responsive design, and proper handling of various data types. Deduct 5 points if no sorting functionality, 3 points if the table is not responsive, and 5 points if complex data types aren't properly displayed. 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 unsupported file types, corrupted files, very large files, browser limitations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Preview thumbnails for image files 2. Syntax highlighting for code files 3. Data visualization options for numerical 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 file parsing methods that do the same thing) 2. Function modules unrelated to file handling and table display 3. Fancy effects that affect performance (e.g., excessive animations during file loading). 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 file handling/data processing/UI rendering layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Feedback when files are being processed ≤ 200ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual guidance for drop zones. Deduct 5 points for each operation without feedback, 3 points for jerky animations during table rendering, and 5 points for confusing drag and drop areas. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Batch Processing",
+  "difficulty": "hard"
+}