@getollie/cli 0.0.4 → 0.2.0

package/library/utility_tools-automation/automated-unmanned-printing-system.json

@@ -1,68 +0,0 @@
-{
-  "index": 1029,
-  "question": "You are a coding expert, please use your professional knowledge to generate accurate and professional responses. Take care to ensure the code you generate is executable. I specialize in automated printing. Please help me develop a simple yet sophisticated unmanned printing system.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core printing functionality properly implemented?",
-      "description": "Review whether the code accurately implements essential printing functions: queue management, document processing pipeline, and printer communication protocols (such as IPP, CUPS, or direct driver integration). Score 0 if core printing logic is missing, 5 if basic printing is implemented without proper error handling, and 10 if the system includes comprehensive printing capabilities with status monitoring.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the automated workflow management system complete?",
-      "description": "Check if the code implements a complete workflow from file submission to final printing, including file validation, preprocessing (format conversion if needed), print job scheduling, and post-processing notifications. Deduct 3 points if file validation is inadequate, 3 points if job prioritization is missing, and 4 points if there's no completion notification system. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the user interface for self-service printing intuitive and accessible?",
-      "description": "Evaluate whether the interface provides clear step-by-step guidance for users, supports multiple file upload methods, offers preview functionality, and includes payment processing if required. Deduct 3 points for confusing navigation, 3 points for limited file format support, and 4 points if the preview functionality is missing or inadequate. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a comprehensive error handling and recovery system?",
-      "description": "Assess whether the code includes robust error detection for common printing issues (paper jams, low toner, connectivity problems), provides clear user notifications, and implements recovery procedures. Deduct 3 points if error detection is limited, 3 points if notifications are unclear, and 4 points if recovery procedures are inadequate or missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle edge cases such as unexpected file formats, large print jobs, concurrent user requests, power outages, and network interruptions. Code with strong robustness should gracefully handle these scenarios with appropriate logging and recovery mechanisms, giving 10 points. If the robustness is average, give 5 points, and if no exception handling exists, 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. Mobile app integration with QR code submission 2. AI-based document optimization for print quality 3. Smart resource estimation before printing 4. Print job analytics dashboard). 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 processing pipelines) 2. Function modules unrelated to printing (e.g., unnecessary multimedia features) 3. Fancy effects that affect system performance (e.g., excessive animations in the interface). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating UI/business logic/printer communication layers), unit test coverage, and deployment 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 configuration management is poor with hardcoded values. 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) Response time for user actions ≤ 100ms 2) Clear progress indicators for printing operations 3) Intuitive status updates and feedback. Deduct 5 points for each operation without feedback, 3 points for confusing state transitions, 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/avalonia-dynamic-viewmodel-reflection-code-generation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1353,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the generated code is executable for demonstration. Generate Avalonia axaml page code, control code, and view models dynamically based on table names, table fields, field classes, field control types, field visibility, field default values, etc. Use reflection to dynamically create properties and add them to the view model at runtime.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the dynamic AXAML generation system fully implemented?",
-      "description": "Review whether the code correctly generates Avalonia AXAML based on table metadata. Check if it handles different layout types (Grid, StackPanel, DockPanel), properly sets column definitions and row definitions, and correctly positions controls. Score 0 if dynamic AXAML generation is not implemented, 5 if basic generation works but with layout issues, and 10 if the generation system is complete with proper nesting and responsive layout.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all control types properly supported and instantiated?",
-      "description": "Verify that the code can dynamically create and configure different Avalonia controls (TextBox, ComboBox, DatePicker, CheckBox, etc.) based on field types. Check if control-specific properties and behaviors are correctly set. Deduct 2 points for each unsupported common control type, and 5 points if custom control templates are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the reflection-based property system correctly implemented?",
-      "description": "Evaluate whether the code uses reflection to dynamically create properties at runtime and add them to view models. Check for proper implementation of INotifyPropertyChanged, property change notifications, and type-safe property access. Deduct 5 points if dynamic property creation is not implemented, 3 points if property change notifications are missing, and 2 points if type conversion is not handled properly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are data binding and validation mechanisms properly implemented?",
-      "description": "Check if the code implements two-way data binding between the dynamically generated UI and view model properties. Verify that input validation, error reporting, and error visualization work correctly. Deduct 5 points if data binding is one-way only, 3 points if validation is missing, and 5 points if there's no visual feedback for validation errors. 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 metadata, invalid field types, null references, 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. Live preview of generated UI 2. Metadata editor with real-time AXAML updates 3. Theme switching for generated controls). 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 reflection helper methods doing the same thing) 2. Function modules unrelated to dynamic UI generation 3. Overly complex code that could be simplified. 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 metadata handling/code generation/view model creation), unit test coverage, and proper error handling. Deduct 5 points if there's tight coupling between components; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no exception handling strategy. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the generated UI meet professional design standards?",
-      "description": "Evaluate whether the generated UI follows modern design principles: 1) Proper control spacing and margins 2) Consistent form layout with aligned labels and inputs 3) Professional visual hierarchy of elements. Deduct 3 points for poor alignment of form elements, 5 points for inconsistent spacing between controls, and 5 points for poor visual hierarchy. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the dynamic UI updates conform to good UX practices: 1) Fast property updates without UI freezing 2) Smooth transitions when showing/hiding controls 3) Responsive feedback during long operations. Deduct 5 points for UI freezes during updates, 3 points for jarring control visibility changes, and 5 points for lack of loading indicators during long operations. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "hard"
-}

package/library/utility_tools-automation/bi-weekly-plan-random-selector-tool.json

@@ -1,68 +0,0 @@
-{
-  "index": 1566,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration. Help me create a bi-weekly plan random selection tool using Python with buttons that randomly selects from the following items: Wood Carving, I Ching, Seal Engraving, Shoujinti Calligraphy, Butterfly Knife, Sketching, Small Liuren Divination, Chess, HTML Front-end Development, Piano, Sign Language, Novel, Comic Strip, Traditional Chinese Medicine, 3D Printing, Website Development, 3D Modeling, Braille. The buttons should be light gray, the page background should be black, and the text should be white. I have a website and need clear code that I can integrate into my webpage.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core random selection functionality properly implemented?",
-      "description": "Evaluate whether the Python code correctly implements a random selection algorithm that evenly distributes the probability across all items. Check if the selection is truly random (using appropriate libraries like random.choice) and if it avoids repetition in consecutive selections. Score 0 if randomization is missing, 5 if basic randomization exists but lacks proper distribution, and 10 if it includes both even distribution and protection against repeated consecutive selections.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the bi-weekly plan concept properly reflected in the implementation?",
-      "description": "Check if the tool addresses the bi-weekly nature of the planning. Does it track selection history? Does it have date tracking or scheduling capabilities? Does it prevent the same activity from being selected twice in the same bi-weekly period? Deduct 3 points if it lacks date tracking, 3 points if it doesn't maintain history, and 4 points if it allows duplicate selections within the same period. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the UI implementation complete with the specified design requirements?",
-      "description": "Verify that the interface strictly follows the specified color scheme (light gray buttons, black background, white text). Check if the buttons are properly styled, accessible, and responsive. Deduct 3 points if colors don't match specifications, 3 points if buttons are poorly styled, and 4 points if the interface is not responsive to different screen sizes. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the code structured for easy website integration?",
-      "description": "Evaluate whether the provided code can be easily integrated into an existing website. Check for modular design, self-contained components, minimal dependencies, and clear documentation on how to integrate. Deduct 3 points if external dependencies aren't clearly specified, 3 points if integration instructions are missing, and 4 points if the code heavily modifies existing page structure. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as browser inconsistencies, failed random selections, empty item lists, 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. Animation effects when selecting an item 2. Option to exclude certain activities 3. History tracking with visual representation). 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 random selection methods) 2. Function modules unrelated to the random selection tool (e.g., unnecessary analytics) 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 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 logic/view layers), code reusability, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code is not well-documented with comments. 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 (proper contrast between black background, white text, and light gray buttons) 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 poor contrast or readability, 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 when an item is selected. Deduct 5 points for each operation without feedback, 3 points for sluggish response times, and 5 points for confusing or unclear selection indication. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "easy"
-}

package/library/utility_tools-automation/build-project-react-vite-typescript.json

@@ -1,68 +0,0 @@
-{
-  "index": 816,
-  "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. Build a project using React 18.3.1 version and Vite with TypeScript.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the React 18.3.1 project with Vite and TypeScript correctly initialized?",
-      "description": "Check if the project setup includes proper configuration files (package.json with correct dependencies, tsconfig.json, vite.config.ts). Verify React 18.3.1 is specified correctly and Vite is configured for TypeScript. Score 0 if basic setup is missing, 5 if some configurations are incorrect or incomplete, 10 if fully and properly configured.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are React 18.3.1 specific features utilized appropriately?",
-      "description": "Evaluate whether the code leverages React 18.3.1 specific features like useOptimistic, useFormStatus, use hook, or other new APIs. Deduct 5 points if no React 18.3.1 features are used, 3 points if they're used inappropriately. Give 10 points if features are implemented correctly with proper error boundaries and fallbacks.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is TypeScript properly integrated and utilized throughout the codebase?",
-      "description": "Analyze the TypeScript implementation including proper type definitions, interfaces, generics, and type guards. Check for strict mode usage and proper typing of props, state, and function parameters/returns. Deduct 5 points for any use of 'any' type without justification, 3 points for missing type definitions. Full score requires comprehensive typing with no type errors.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the project follow proper Vite configuration and optimization?",
-      "description": "Check for correct Vite configuration including environment variables, build optimizations, and proper plugin setup. Verify if code-splitting is implemented, assets are optimized, and development features like HMR are working. Deduct 5 points if build process is not optimized, 3 points if environment configurations 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 abnormal situations (such as network failures, unexpected input, component errors) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should use ErrorBoundary components, implement proper form validation, and handle async operations correctly, 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. Custom hooks for complex state management 2. Animated transitions between components 3. Performance optimizations like memoization). 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 re-renders or inefficient component structures 2. Unused imports, components, or code 3. Excessive dependencies that could be replaced with built-in functionality. 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 folder structure, component organization, code reusability, and build pipeline. Check for proper separation of concerns, custom hook abstractions, and testable code. Deduct 5 points if component organization is chaotic; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no 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) 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 jank during animations, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "easy"
-}

package/library/utility_tools-automation/chrome-extension-webpage-control.json

@@ -1,68 +0,0 @@
-{
-  "index": 386,
-  "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. I am currently writing a Chrome browser extension.\n\nI want to implement the ability to control target webpage elements' clicking through my extension window.\n\nMy current browser extension page is as follows:\n```html\n<!DOCTYPE html>\n<html>\n<head>\n  <meta charset=\"utf-8\">\n  <title>Order Assistant</title>\n  <!-- Must strictly maintain loading order -->\n  <script src=\"js/jquery.min.js\"></script>\n  <script src=\"js/jquery.cookie.js\"></script>\n  <script src=\"js/miaoshou.js\"></script>\n  <script src=\"js/main.js\" type=\"module\"></script>\n\n  <link rel=\"stylesheet\" type=\"text/css\" href=\"css/main.css\">\n</head>\n<body>\n  <button id=\"getOrderBtn\" class=\"jq-btn\">Get Order</button>\n  <button id=\"refreshOrderBtn\" class=\"jq-btn\">Refresh Order</button>\n  <div id=\"resultContainer\"></div>\n</body>\n</html>\n```\n\nI'm using \"manifest_version\": 3,\nThe target website I want to operate on is erp.91miaoshou.com\nThe button to operate is the search button with attribute .J_queryFormSearch\nI want to use the query.main.js library.\nPlease help me output the complete extension code and the calling method.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Content Script properly implemented to interact with target webpage?",
-      "description": "Check if the code properly implements a content script that can access and interact with DOM elements on erp.91miaoshou.com. It should include proper event listeners, message passing mechanisms between content script and background/popup, and target the correct elements (.J_queryFormSearch). Score 0 if content script is missing, 5 if basic implementation exists but has limitations, 10 if fully implemented with error handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Message Passing mechanism between extension components properly implemented?",
-      "description": "Evaluate whether the code implements Chrome extension message passing (chrome.tabs.sendMessage/chrome.runtime.sendMessage) correctly for communication between popup, background script, and content script. Check for proper message formatting, response handling, and error handling. Deduct 5 points if one-way communication only, 3 points if error handling is missing. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the manifest.json file correctly configured?",
-      "description": "Check if manifest.json follows Manifest V3 specification with proper permissions (host permissions for erp.91miaoshou.com), content scripts declaration with correct matches, background script configuration, and web_accessible_resources if needed. Deduct 3 points for each missing critical permission, 5 points for incorrect content script matching patterns, and 5 points for security issues like excessive permissions. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the integration with query.main.js library properly implemented?",
-      "description": "Verify whether query.main.js is correctly incorporated and utilized in the extension. Check if it's properly loaded, initialized, and used for DOM manipulation. Examine if the library's dependencies are handled correctly. Deduct 5 points if the library is included but not properly initialized, 3 points if there are conflicts with jQuery, 5 points if the library functionality is reimplemented instead of using the library. 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 target element not found, website structure changes, network issues, permission denials, 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. Advanced element targeting with fallback selectors 2. Visual feedback for clicked elements 3. Automated action sequences). 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 access the DOM) 2. Function modules unrelated to the clicking operation (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., complex 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 logic/DOM manipulation/message passing), 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 clear separation of concerns. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the extension UI 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 extension interaction smooth and responsive?",
-      "description": "Judge whether the interaction flows conform to user expectations: 1) Click feedback delay ≤ 100ms 2) Clear visual indication of operation success/failure 3) Logical workflow from popup to target website. Deduct 5 points for each operation without feedback, 3 points for delayed responses (> 300ms), and 5 points for confusing user flow. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "easy"
-}

package/library/utility_tools-automation/chrome-plugin-spotlight-search-vue3-naive-ui.json

@@ -1,68 +0,0 @@
-{
-  "index": 1647,
-  "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. Develop a Chrome plugin with a feature that listens for the Alt+X shortcut key to open a search box, similar to Apple's Spotlight Search, using Vue 3 and Naive UI.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Chrome extension core structure properly implemented?",
-      "description": "Verify if the code includes all essential Chrome extension files (manifest.json, background.js, popup.html, etc.) with proper configuration. Check if the manifest.json correctly specifies permissions (commands for keyboard shortcuts, tabs, storage), and if version 3 manifest standards are followed. Score 0 if essential files are missing, 5 if basic structure exists but has configuration issues, 10 if fully implemented according to Chrome extension best practices.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Alt+X keyboard shortcut properly implemented?",
-      "description": "Evaluate whether the extension correctly registers and listens for the Alt+X keyboard shortcut using Chrome's commands API. Check if the shortcut works globally across tabs and is properly defined in manifest.json. Verify error handling when the shortcut might be unavailable. Score 0 if shortcut functionality is missing, 5 if implemented but not working reliably, 10 if fully functional with appropriate fallbacks.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the search box UI properly implemented with Vue 3 and Naive UI?",
-      "description": "Check if Vue 3's Composition API is used correctly and if Naive UI components are properly imported and configured. Verify if the search box appears centered on screen with proper focus, has appropriate styling (blur effect, rounded corners, etc.), and follows Spotlight's minimalist aesthetic. Deduct 5 points if Vue 3 features are underutilized, 3 points if Naive UI theming is inconsistent, and 5 points if the search box appearance differs significantly from Spotlight.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the search functionality comprehensive and effective?",
-      "description": "Assess whether the search function includes indexing of browser history, bookmarks, open tabs, and potentially web search. Check if results appear in real-time as the user types with proper debouncing (≤150ms), and if categorization of results is clear. Verify if the code implements fuzzy matching algorithms. Score 0 if search is basic text matching only, 5 if it searches multiple sources but lacks optimization, 10 if search is comprehensive with intelligent ranking algorithms.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as conflicting shortcuts, search indexing failures, API rate limits, 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. Custom search providers integration 2. Search history with analytics 3. AI-powered result ranking). 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 search algorithms running simultaneously) 2. Function modules unrelated to search functionality (e.g., built-in games or utilities) 3. Fancy effects that affect performance (e.g., excessive animations or transitions). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating UI/logic/data 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) Search results appear within 200ms after typing 2) Transition animations controlled between 150-300ms 3) Clear keyboard navigation support (up/down arrows, Enter to select). Deduct 5 points for search lag exceeding 500ms, 3 points for janky animations during result rendering, and 5 points for lack of keyboard navigation. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "hard"
-}

package/library/utility_tools-automation/clock-in-out-overtime-reminder-app.json

@@ -1,68 +0,0 @@
-{
-  "index": 1781,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for demonstration. I need your help to write an HTML application that implements the following functions:\n\nRemind to clock in 5 minutes before work starts on each working day (excluding public holidays). Remind to clock out and sign in for overtime at 18:01. Remind to sign out from overtime at 20:31.\n\nThe screen must remain locked until the clock-in/out is completed. Each time someone clocks in or out, they will receive an encouraging message to provide emotional value.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the timed reminder functionality properly implemented?",
-      "description": "Evaluate whether the code correctly implements timed reminders that trigger at the specified times (5 minutes before work starts, 18:01 for clock-out/overtime sign-in, and 20:31 for overtime sign-out). Check if the application correctly excludes weekends and public holidays from the reminder schedule. Deduct 5 points if any of the reminder times are incorrectly implemented, and 5 points if the holiday exclusion logic is missing or flawed. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the screen locking mechanism implemented effectively?",
-      "description": "Check if the application implements a screen locking mechanism that prevents access until clock-in/out is completed. Verify that the lock cannot be easily bypassed and persists until the required action is taken. Deduct 5 points if the lock can be bypassed, 3 points if the lock doesn't persist properly, and 2 points if the lock doesn't provide clear instructions on how to unlock. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are emotional value messages implemented with the clock-in/out system?",
-      "description": "Evaluate whether encouraging messages are displayed after each clock-in/out action. Check for variety in messaging (at least 5 different messages), contextual relevance (morning messages differ from evening ones), and positive emotional tone. Deduct 3 points if messages lack variety, 3 points if they're not context-aware, and 4 points if no messages appear at all. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the clock-in/out tracking system properly implemented?",
-      "description": "Assess whether the application correctly tracks and records clock-in/out events, including regular work hours and overtime. Check for proper data persistence (local storage at minimum), timestamp accuracy, and the ability to view history. Deduct 5 points if data isn't persisted between sessions, 3 points if timestamps are inaccurate, and 2 points if there's no history view. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as browser notifications being blocked, system time discrepancies, offline usage, 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. Statistical visualization of work patterns 2. Personalized motivation system based on user preferences 3. Integration with ambient notifications like subtle screen color changes). 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 notification systems doing the same thing) 2. Function modules unrelated to attendance tracking (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the interface). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating UI/business logic/data persistence layers), unit test coverage, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear organization or commenting. 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) Notification visibility and prominence when triggered 2) Transition animation duration controlled between 300-500ms when locking/unlocking screen 3) Clear visual feedback for successful clock-in/out actions. Deduct 5 points for each operation without feedback, 3 points for jarring transitions between states, and 5 points for notifications that are easy to miss. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "easy"
-}

package/library/utility_tools-automation/cloud-based-clipboard-sync-tool-with-real-time-features.json

@@ -1,68 +0,0 @@
-{
-  "index": 503,
-  "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 purposes. Develop a cloud-based clipboard synchronization tool that supports real-time synchronization across devices, content format preservation (text/images/rich text), encrypted transmission, history rollback, and quick content retrieval functionality.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the multi-device clipboard synchronization system fully implemented?",
-      "description": "Review whether the code correctly implements real-time clipboard synchronization across different devices. Check if it uses WebSockets or Server-Sent Events for real-time updates, has proper connection management, and handles device authentication. Score 0 if synchronization is not implemented, 5 if basic text synchronization works but with delays (>1s), and 10 if synchronization is real-time (<500ms) across all devices with proper conflict resolution.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the solution support all required content formats?",
-      "description": "Evaluate support for multiple content types: plain text, rich text (HTML/markdown), and images. Check if the code properly handles encoding/decoding, maintains formatting integrity during transfer, and correctly renders all content types on the receiving end. Deduct 3 points if a required format is missing, 2 points if image compression significantly degrades quality, and 2 points if rich text formatting is lost during synchronization. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the encrypted transmission properly implemented?",
-      "description": "Examine the encryption implementation for both data in transit and at rest. Check for use of industry-standard encryption (TLS for transmission, AES for storage), secure key management, and end-to-end encryption. Deduct 5 points if only basic HTTPS is used without additional encryption layers, 3 points if encryption keys are stored insecurely, and 5 points if sensitive data is transmitted or stored in plaintext. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the history and rollback mechanisms fully functional?",
-      "description": "Verify the implementation of clipboard history tracking, storage efficiency, and the ability to restore previous clipboard states. Check if the code maintains a proper version history with timestamps, allows browsing through past entries, and supports one-click restoration of previous clipboard content. Deduct 3 points if history is limited to text-only, 3 points if the rollback mechanism is unreliable, and 5 points if there's no way to manage history storage size. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as network disconnections, synchronization failures, concurrent edits, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle offline operation modes with data queuing for sync. Give 10 points for comprehensive error handling and recovery, 5 points for basic error handling, and 0 points if exceptions cause the system to fail.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Smart content categorization 2. OCR for images with text 3. Context-aware suggestions 4. Cross-platform browser extensions). 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 storage mechanisms without clear purpose) 2. Function modules unrelated to clipboard synchronization (e.g., built-in messaging system) 3. Resource-intensive features that affect performance (e.g., unnecessary background processing). Deduct 3 points for each redundancy found, and directly deduct 10 points if core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating sync logic/UI/storage layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Clipboard paste operation completes in ≤ 100ms 2) Visual feedback for synchronization status 3) Clear indication of encrypted vs. unencrypted content. Deduct 5 points for each operation without feedback, 3 points for laggy performance during large content synchronization, and 5 points for confusing UI that doesn't clearly show sync status. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "hard"
-}