@getollie/cli 0.0.1

package/library/utility_tools-daily_office_tasks/to-do-list-mini-program-in-english.json

@@ -0,0 +1,68 @@
+{
+  "index": 1278,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the code you generate is executable. Provide me with a to-do list mini program developed in English.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic CRUD functionality of the to-do list properly implemented?",
+      "description": "Check whether the code accurately implements the four basic operations (Create, Read, Update, Delete) for to-do items. The creation function should support adding new tasks with at least title and status properties. The read function should display all tasks clearly. The update function should allow modification of task properties (status, title, etc.). The delete function should remove tasks completely. Score 0 if core CRUD functionality is missing, 5 if only partial functionality works, 10 if all operations are fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the task prioritization and categorization system included?",
+      "description": "Evaluate whether the to-do list allows users to prioritize tasks (e.g., high, medium, low) and categorize them (e.g., work, personal, shopping). Check if the tasks can be sorted or filtered based on these attributes. Deduct 5 points if prioritization is missing, 3 points if categorization is missing, and 5 points if sorting/filtering functionality is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are persistent storage and data synchronization implemented?",
+      "description": "Check whether the application implements data persistence using localStorage, IndexedDB, or a backend database. Verify if the data survives page refreshes and browser restarts. For multi-device synchronization, check if a mechanism is implemented to handle data conflicts. Deduct 5 points if no persistence is implemented, 3 points if only temporary storage is used, and 5 points if no synchronization mechanism exists. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a task scheduling and notification system?",
+      "description": "Evaluate whether the to-do list includes date/time scheduling for tasks with due dates and reminder functionality. Check if the application can send notifications for upcoming tasks. Verify if recurring tasks can be set up (daily, weekly, monthly). Deduct 3 points if scheduling is missing, 3 points if notification capability is absent, and 4 points if recurring tasks aren't supported. 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 input, network interruption, data corruption, etc.) and provide friendly error prompts or recovery mechanisms. Check for input validation, error handling, and graceful degradation when features aren't available. 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. Productivity statistics/analytics 2. Natural language input for quick task creation 3. Task templates for common activities 4. Gamification elements like streaks or achievements). 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 delete tasks) 2. Function modules unrelated to to-do list management (e.g., a built-in calculator) 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 data/view/controller layers), code organization, and maintainability. Check for consistent naming conventions, appropriate comments, and clean code practices. 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 are no tests or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times) 4) Clear visual hierarchy between completed and pending tasks. 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) Immediate visual feedback when marking tasks complete 2) Smooth transitions when adding/removing tasks 3) Clear visual focus guidance 4) Intuitive drag-and-drop for reordering tasks. Deduct 5 points for each operation without feedback, 3 points for janky animations during interactions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "easy"
+}

package/library/utility_tools-daily_office_tasks/to-do-reminder-interface-with-time-limits.json

@@ -0,0 +1,68 @@
+{
+  "index": 869,
+  "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. Design a to-do reminder interface that includes processing time limits.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core to-do reminder functionality fully implemented?",
+      "description": "Check if the code implements the essential features of a to-do list: adding tasks, marking them as complete, deleting tasks, and setting time limits/deadlines. Score 0 if the core functions are missing, 5 if only basic functionality exists, and 10 if all core features with proper state management are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the time limit functionality properly implemented?",
+      "description": "Verify that the time limit feature includes deadline setting, visual countdown indicators, overdue status handling, and reminders. Deduct 3 points if deadline validation is missing, 3 points if there's no visual differentiation between upcoming, urgent and overdue tasks, and 4 points if notification/reminder functionality is absent. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the data persistence mechanism implemented?",
+      "description": "Evaluate whether the application saves to-do items between sessions (using localStorage, IndexedDB, or other storage methods). Check if it handles storage errors gracefully and includes data validation before storage. Deduct 5 points if no persistence is implemented, 3 points if data validation is missing, 2 points if there's no error handling for storage operations. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is filtering and sorting functionality provided?",
+      "description": "Check whether the interface allows users to filter tasks by status (completed/pending), sort by priority or deadline, and supports search functionality. Deduct 3 points if filtering is missing, 3 points if sorting options are limited, and 4 points if there's no search capability. 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 date inputs, duplicate tasks, browser storage 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. Task prioritization with visual indicators 2. Recurring task support 3. Drag-and-drop task organization 4. Progress tracking for complex tasks). Add 2.5 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 task updating mechanisms) 2. Function modules unrelated to to-do management (e.g., a built-in calculator) 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 task data/view/controller layers), event delegation patterns, and code reusability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 3 points if the code duplication rate is too high (over 30%); deduct 2 points if there's no code 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) 4) Clear visual hierarchy for task priority and deadlines. 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 for time-sensitive tasks. Deduct 5 points for each operation without feedback, 3 points for jarring transitions when manipulating tasks, and 5 points for confusing interactions when setting time limits. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "easy"
+}

package/library/utility_tools-daily_office_tasks/typescript-canvas-rich-text-editor.json

@@ -0,0 +1,68 @@
+{
+  "index": 1476,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable when possible. Help me implement a high-performance canvas-based rich text editor using TypeScript class style.\n\nThe editor should have the following features: support for multiple lines, text selection, font styles (bold, italic, underline, strikethrough), font size and color, text alignment (left, center, right, justified), line height and letter spacing, superscript and subscript, lists (ordered and unordered), indentation and spacing, support for multi-step undo and redo operations, support for copy, cut and paste (including pasting content from Word, websites and other sources while clearing redundant formatting), and data saved in JSON format that is space-efficient.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the canvas-based text rendering system fully implemented?",
+      "description": "Review whether the code correctly implements a canvas-based text rendering engine that handles font metrics, text measurement, and proper text layout. Check if it correctly renders different styles (bold, italic, underline, strikethrough) with proper weight and appearance. Score 0 if core text rendering is missing, 5 if basic rendering works but with visual glitches, and 10 if text renders accurately with all required styles.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is text selection functionality properly implemented?",
+      "description": "Evaluate the text selection mechanism. It should include: 1) Proper highlighting of selected text 2) Accurate cursor positioning 3) Word/paragraph selection with double/triple clicks 4) Keyboard navigation with modifiers (Shift+arrows). Deduct 3 points if selection highlighting has rendering issues, 3 points if keyboard selection is missing, and 4 points if selection across styling boundaries fails. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are all required text styling features implemented?",
+      "description": "Check for complete implementation of: font styles (bold, italic, underline, strikethrough), font size/color, text alignment (left, center, right, justified), line height, letter spacing, superscript/subscript, and lists (ordered/unordered). For each missing feature deduct 1 point. For features with partial implementation (e.g., works visually but not in the data model), deduct 0.5 points. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the undo/redo system and clipboard functionality complete?",
+      "description": "Examine the implementation of multi-step undo/redo operations and clipboard functions. Check that operations are properly batched for logical editing actions. For clipboard, verify proper handling of internal copying/pasting and external content with format cleaning (from Word, websites). Deduct 3 points for missing undo/redo, 3 points for basic clipboard issues, and 4 points if format cleaning from external sources is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common edge cases (very long text, unusual Unicode characters, rapid input, large paste operations, etc.) and provide appropriate error handling or recovery mechanisms. Code with strong robustness should handle these edge cases effectively, giving 10 points. If the robustness is average, give 5 points, and if edge cases crash the editor, 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 collaboration capability 2. Auto-save with version history 3. Markdown shortcuts 4. Performance optimizations for large documents). Add 2.5 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 selection models) 2. Feature modules unrelated to rich text editing (e.g., built-in image editing) 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 TypeScript class design (proper use of interfaces, access modifiers, generics), modular architecture (separation of rendering/model/controller), code reusability, and test coverage. Deduct 3 points if TypeScript features are underutilized; deduct 3 points if the architecture lacks clear separation of concerns; deduct 4 points if there's significant code duplication or poor maintainability. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the editor interface meet professional design standards?",
+      "description": "Evaluate whether the editor follows modern design principles: 1) Clean, distraction-free editing area 2) Proper spacing between lines and paragraphs 3) Consistent cursor behavior and selection highlighting 4) Appropriate toolbar layout with clear iconography. Deduct 3 points for poor visual hierarchy, 3 points for inconsistent styling, and 4 points for cluttered interface elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the editor performance optimized?",
+      "description": "Judge the performance characteristics: 1) Input latency ≤ 16ms (60fps) 2) Efficient canvas redrawing strategies (partial updates vs. full redraws) 3) Memory management for large documents 4) JSON serialization efficiency. Deduct 3 points if typing shows noticeable lag, 3 points if scrolling large documents is jerky, and 4 points if memory usage grows uncontrollably with document size. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "hard"
+}

package/library/utility_tools-daily_office_tasks/uni-app-vue2-clock-in-page.json

@@ -0,0 +1,68 @@
+{
+  "index": 1652,
+  "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. Help me write a clock-in page using uni-app vue2.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the uni-app clock-in core functionality fully implemented?",
+      "description": "Review whether the code accurately implements clock-in/clock-out functionality through uni-app framework, including time recording, attendance status management, and local storage persistence. Score 0 if core clock-in logic is not implemented, 5 if only basic time recording is present, and 10 if complete attendance tracking with validation is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Vue2 component architecture properly structured?",
+      "description": "Check whether the Vue2 implementation follows proper component lifecycle management, data binding, and state management patterns. Evaluate if uni-app specific APIs (uni.getLocation, uni.getStorage, etc.) are correctly integrated. Deduct 5 points if component communication is poorly implemented, and 3 points if lifecycle hooks are misused. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are location-based attendance and data persistence implemented?",
+      "description": "Evaluate whether the system includes GPS location verification for clock-in validity, local data storage using uni.setStorage, and offline capability. Check if attendance records are properly structured and retrievable. Deduct 5 points if location services are not integrated, 3 points if data persistence is unreliable. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is comprehensive attendance management and history tracking constructed?",
+      "description": "Check whether the code includes complete attendance lifecycle management, including daily/weekly/monthly attendance summaries, history viewing, and statistical analysis. Deduct 5 points if attendance history is not properly displayed, and 3 points if statistical calculations are missing. Give 10 points if fully implemented with export functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as GPS failure, storage quota exceeded, network interruption, permission denial, 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. Facial recognition for identity verification 2. Automatic work schedule detection 3. Team attendance leaderboard 4. Weather-based attendance reminders). 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 time calculation methods coexisting) 2. Function modules unrelated to attendance (e.g., built-in games or social features) 3. Fancy effects that affect performance (e.g., heavy animation libraries). 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 business logic/components/utils), proper use of uni-app conventions, and code organization. Deduct 5 points if global state pollution is found or Vue2 best practices are not followed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if uni-app specific optimizations are ignored. 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 mobile design principles: 1) Harmonious color matching suitable for work environment (no more than 3 primary colors) 2) Proper layout spacing following mobile design guidelines (touch targets ≥ 44px) 3) Professional typography system (body font size ≥ 14px for mobile readability). Deduct 3 points for each crowded visual element, 5 points for unprofessional color schemes, and 5 points for poor mobile layout adaptation. 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 mobile interaction patterns: 1) Touch feedback delay ≤ 100ms 2) Page transition animations optimized for mobile performance 3) Clear visual hierarchy and navigation flow 4) Proper handling of mobile-specific interactions (swipe, pull-to-refresh). Deduct 5 points for each operation without proper mobile feedback, 3 points for laggy animations on mid-range devices, and 5 points for confusing navigation patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "easy"
+}

package/library/utility_tools-daily_office_tasks/uniapp-alibaba-cloud-one-click-login.json

@@ -0,0 +1,68 @@
+{
+  "index": 1138,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional replies. Be careful to ensure that the generated code is executable and can be displayed. Write a uniapp APP with Alibaba Cloud one-click mobile phone number login.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Alibaba Cloud mobile phone number login integration complete?",
+      "description": "Review whether the code correctly implements the Alibaba Cloud mobile number login SDK with proper initialization, configuration parameters, and authorization flow. Verify that AccessKeyId, AccessKeySecret, and bundle ID/package name are properly configured. Score 0 if missing critical components, 5 if basic login flow works but lacks security measures, and 10 if fully implemented with proper token handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the uni-app framework setup correct?",
+      "description": "Check if the project structure follows uni-app conventions, manifest.json is properly configured with Alibaba Cloud dependencies, pages are registered correctly, and HBuilderX plugins for Alibaba Cloud services are installed. Verify cross-platform compatibility settings (iOS/Android). Deduct 5 points if platform-specific adaptation is missing, 3 points if dev/prod environments aren't separated. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the login user interface properly implemented?",
+      "description": "Evaluate whether the login UI includes branded elements, proper loading states, error handling visualization, and smooth transition animations. Check for proper rendering on different screen sizes. Deduct 5 points for non-responsive design, 3 points for missing loading indicators, and 5 points for poor error message display. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is user authentication state management implemented?",
+      "description": "Verify the implementation of token storage, refresh mechanisms, session expiration handling, and automatic re-login capabilities. Check for secure storage using uni.setStorageSync with encryption for sensitive data. Deduct 5 points if token persistence is insecure, 5 points if refresh logic is missing, and 3 points if session timeout isn't properly handled. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruption, SDK initialization failures, 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. Biometric authentication fallback 2. Custom animated login transitions 3. Intelligent network status detection with adaptive UI). 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 authentication methods 2. Function modules unrelated to login flow (e.g., built-in profile editors before even logging in) 3. Fancy effects that affect performance (e.g., heavy animations during critical login processes). 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 API calls/UI/state management layers), error handling patterns, and build process optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation between Alibaba Cloud service layer and business logic. 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) Login button feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual guidance during the authentication flow. Deduct 5 points for each operation without feedback, 3 points for visual stuttering during animations, and 5 points for confusing authentication progress indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "hard"
+}

package/library/utility_tools-daily_office_tasks/vision-test-program-random-e-directions.json

@@ -0,0 +1,68 @@
+{
+  "index": 1416,
+  "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. Is there a simple method to create a vision test program that randomly displays the letter E facing different directions?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core vision test functionality correctly implemented?",
+      "description": "Evaluate whether the code accurately implements a vision test with the letter E displayed in random orientations (up, down, left, right). Check if the orientation is truly randomized and whether the display timing is appropriate for testing purposes. Score 0 if the core functionality is missing, 5 if basic implementation is present but has flaws, and 10 if fully implemented with proper randomization.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the user interaction mechanism properly designed?",
+      "description": "Review how users indicate their perception of the E's orientation (keyboard input, button clicks, touch gestures, etc.). Check for input validation, clear instructions, and appropriate feedback after each response. Deduct 5 points if the interaction is confusing, 3 points if feedback is missing, and 2 points if instructions are unclear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the vision test properly parameterized for clinical application?",
+      "description": "Examine whether the code includes configurable parameters essential for vision testing, such as letter size (for acuity testing), contrast levels, display time, and viewing distance calculation. Deduct 3 points for each missing key parameter, and 5 points if the test doesn't follow any established vision testing protocol. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a scoring/results system to track testing performance?",
+      "description": "Verify if the program includes a mechanism to track correct/incorrect responses, calculate success rates, and present meaningful results to determine vision quality. Check for proper data collection, analysis logic, and result presentation. Deduct 5 points if there's no scoring system, 3 points if results aren't properly analyzed, and 2 points if the results presentation is inadequate. 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 user inputs, screen size changes, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Multiple optotype options beyond the letter E 2. Progressive difficulty adjustment based on performance 3. Color vision testing component). 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 enter the same response) 2. Function modules unrelated to vision testing (e.g., unnecessary animations or effects) 3. Fancy effects that affect performance or distract from the test. 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 test logic/view/data collection layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or documentation. 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 medical testing interface standards: 1) Clean background with appropriate contrast 2) Proper layout with clear focal point 3) Professional typography with adequate size for instructions. Deduct 3 points for each distracting visual element, 5 points for poor contrast that would affect test validity, and 5 points for confusing layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the testing flow is appropriate for clinical use: 1) Appropriate timing between stimuli presentations 2) Smooth transition between test items 3) Clear visual focus during test execution. Deduct 5 points for jarring transitions that could affect test results, 3 points for inconsistent timing between stimuli, and 5 points for interaction issues that would invalidate test results. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "hard"
+}

package/library/utility_tools-daily_office_tasks/vs-code-excel-import-print-no-office.json

@@ -0,0 +1,68 @@
+{
+  "index": 884,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable. How can I use VS CODE to create a small program that imports content from Excel spreadsheets and adds a print button for printing, allowing computers without Office software installed to print Excel tables?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Excel file import function correctly implemented?",
+      "description": "Evaluate whether the code can properly parse different Excel file formats (XLS, XLSX, CSV), handle large files without performance issues, and correctly preserve formatting (including merged cells, number formats, etc.). Deduct 5 points if only one file format is supported, 5 points if large files (>5MB) cause memory issues, and 5 points if complex formatting is lost. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the visual representation of Excel data complete and accurate?",
+      "description": "Check if the code properly displays all Excel components (tables, charts, formulas) with correct styling (fonts, colors, borders, cell alignments). Deduct 5 points if formula results are shown but not the formulas themselves when needed, 3 points if styling significantly differs from the original Excel file, and 5 points if charts or complex tables are not rendered correctly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the print functionality properly implemented?",
+      "description": "Assess if the print feature supports page setup options (orientation, margins, scaling), print preview, and generates a print-ready version that accurately represents the Excel data. Deduct 5 points if page setup options are missing, 3 points if the print preview doesn't match the actual output, and 5 points if the printed output has significant formatting issues. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the solution compatible with computers without Office installed?",
+      "description": "Verify that the code works completely independently of Microsoft Office components, using only web technologies or standalone libraries that don't require Office dependencies. Check if installation instructions are clear and account for different operating systems. Deduct 10 points if any dependency on Office components exists, 5 points if third-party libraries require complex installation steps. 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 corrupted Excel files, unsupported features, encoding 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. Batch processing of multiple files 2. Excel sheet selection and filtering options 3. Print-specific optimizations like header/footer customization). 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 libraries or dependencies that serve the same purpose 2. Feature modules unrelated to Excel viewing or printing 3. Unnecessary processing steps that slow down performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating file parsing/display/printing layers), error handling coverage, and project structure. Deduct 5 points if global variables are overused or proper design patterns are not applied; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if proper documentation is missing. 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) File loading feedback with progress indication 2) Print dialog appears within 300ms of button click 3) Clear visual indicators during processing steps. Deduct 5 points for operations without feedback, 3 points for laggy UI during file processing, and 5 points for confusing navigation or hidden important features. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "medium"
+}

package/library/utility_tools-daily_office_tasks/vue-2-frontend-pdf-fill-in-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 1721,
+  "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. Vue 2 frontend PDF fill-in tool.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the PDF rendering and display functionality properly implemented?",
+      "description": "Check if the code uses a reliable PDF rendering library (like PDF.js) that correctly displays PDFs in Vue 2. Verify that the PDF is properly loaded, displayed with correct dimensions, and supports different zoom levels. Score 0 if PDF rendering is not implemented, 5 if basic display works but lacks zoom/navigation features, and 10 if fully implemented with proper error handling for corrupt files.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the tool implement comprehensive form field manipulation?",
+      "description": "Evaluate whether the code can detect, parse, and manipulate all standard PDF form fields (text inputs, checkboxes, radio buttons, dropdowns, signatures). Check if positioning is accurate and if editing capabilities respect field constraints (e.g., max characters, numerical validation). Deduct 3 points if signature fields aren't supported, 2 points if field validation is missing, and 2 points if field formatting options are absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete data binding mechanism between Vue and PDF form data?",
+      "description": "Assess how effectively the code implements two-way data binding between Vue's reactive system and PDF form fields. Check for proper reactivity, whether updates in Vue models reflect immediately in the PDF and vice versa. Deduct 5 points if binding is one-way only, 3 points if there are noticeable update delays, and 5 points if the binding breaks when handling complex field interactions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the tool support saving and exporting the filled PDF?",
+      "description": "Verify if the implementation supports saving the filled PDF with all form data intact. Check for functionality to export the PDF with form data either flattened (for final distribution) or still editable (for later modifications). Deduct 5 points if only one export mode is available, 3 points if exported files lose certain form data, and 5 points if there's no progress indication for large files. 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 malformed PDFs, unsupported PDF features, 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. Auto-filling from external data sources 2. Template saving and management 3. PDF form field extraction to JSON). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple PDF loading methods) 2. Function modules unrelated to PDF form filling (e.g., a built-in file explorer) 3. Fancy effects that affect performance (e.g., unnecessary animations when filling forms). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating PDF rendering/form manipulation/UI components), 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) Form field focus/blur transitions are natural 2) Transition animation duration controlled between 300-500ms 3) Clear visual indication of which field is being edited. Deduct 5 points for each operation without feedback, 3 points for laggy rendering when navigating multi-page PDFs, and 5 points for confusing UI when switching between form fields. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "hard"
+}