@getollie/cli 0.0.1

package/library/utility_tools-daily_office_tasks/develop-computer-keyboard-uni-app.json

@@ -0,0 +1,68 @@
+{
+  "index": 1460,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration purposes. Develop a computer keyboard using uni-app.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic keyboard UI layout correctly implemented?",
+      "description": "Check whether the keyboard layout follows standard QWERTY design with proper key spacing and row alignment. Verify if all standard keys (letters, numbers, function keys) are present and properly sized. Score 0 if basic keyboard structure is missing, 5 if layout exists but has alignment issues, and 10 if the layout is professional and follows standard keyboard conventions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the keyboard event handling system properly implemented?",
+      "description": "Evaluate whether key press/release events are correctly captured and processed. Check if the code handles multi-touch scenarios and prevents ghost touches. The implementation should include visual feedback on key press. Deduct 5 points if key events don't trigger appropriate actions, and 3 points if the code doesn't handle simultaneous key presses. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are special keyboard features implemented?",
+      "description": "Review implementation of modifier keys (Shift, Ctrl, Alt), toggle keys (Caps Lock, Num Lock), and special function keys. Check if the keyboard can switch between different layouts (e.g., alphabetic, numeric, symbol). Deduct 5 points if modifier keys don't change keyboard state properly, and 3 points if layout switching is buggy. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the uni-app cross-platform compatibility addressed?",
+      "description": "Assess whether the code utilizes uni-app framework properly to ensure compatibility across multiple platforms (iOS, Android, H5, etc.). Check if platform-specific APIs are conditionally used when necessary. Deduct 5 points if the code only works on one platform, 3 points if there are minor platform-specific issues. 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 rapid tapping, long-press operations, screen orientation changes, etc.) and provide friendly error 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. Haptic feedback 2. Swipe typing capability 3. Custom theme options 4. Predictive text/auto-complete). 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 event handlers for the same action) 2. Function modules unrelated to keyboard functionality (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., complex animations that slow down key response). 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 layout/event handling/state management), component reusability, and proper use of uni-app best 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 uni-app components are not properly leveraged. 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 keyboard design principles: 1) Consistent key sizes and spacing 2) Clear visual differentiation between key groups 3) Professional color scheme with good contrast for readability 4) Proper use of shadows and highlights for visual depth. Deduct 3 points for each visual inconsistency, 5 points for poor color contrast that affects usability, and 5 points for unprofessional appearance. 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) Key press visual feedback delay ≤ 50ms 2) Smooth animations for layout transitions 3) Proper haptic/audio feedback when available. Deduct 5 points for each key press without feedback, 3 points for laggy animations during typing, and 5 points for unresponsive interfaces during fast typing. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "easy"
+}

package/library/utility_tools-daily_office_tasks/electron-json-tool-macos-desktop-app.json

@@ -0,0 +1,68 @@
+{
+  "index": 341,
+  "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 macOS desktop application using Electron. The application should include a tool list menu where users can select and use corresponding tools.\n\nFirst-level menu: JSON, with second-level menus: JSON Format, JSON DIFF.\n\nWhen clicking the \"JSON Format\" menu, the application should be divided into two rich text boxes internally. The left rich text box is for pasting the original JSON, and the right rich text box displays the formatted (beautified) JSON text.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Electron application structure properly implemented?",
+      "description": "Verify that the code includes essential Electron components: main process (main.js), renderer process, preload scripts, and proper IPC communication. The application should follow the Electron security best practices with contextIsolation enabled and nodeIntegration disabled. Deduct 5 points if missing proper window management (creation, close, minimize), 5 points if missing appropriate security configurations, and 5 points if the application lifecycle isn't handled correctly. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the first-level JSON menu with second-level options correctly implemented?",
+      "description": "Check whether the menu structure is properly defined with 'JSON' as the first-level menu and 'JSON Format' and 'JSON DIFF' as second-level items. The menu should be created using Electron's Menu API with proper event handling. Deduct 5 points if the menu structure is incorrect, 3 points if keyboard shortcuts are missing, and 2 points if menu state management (enabling/disabling based on context) is not implemented. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the JSON Format functionality fully implemented?",
+      "description": "Evaluate whether the JSON Format tool correctly splits the view into two rich text areas, allows pasting in the left panel, and displays properly formatted JSON in the right panel. The formatter should handle indentation, line breaks, and color syntax highlighting. Deduct 5 points if syntax highlighting is missing, 3 points if large JSON files cause performance issues, and 5 points if the formatter doesn't handle JSON validation errors gracefully. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the JSON DIFF functionality properly designed and implemented?",
+      "description": "Assess whether the JSON DIFF tool allows comparing two JSON structures with clear visual indication of differences (additions, deletions, modifications). The diff view should highlight changes using color coding and provide a structured view of changes. Deduct 5 points if the diff algorithm doesn't handle nested structures, 3 points if large JSON comparison is inefficient, and 5 points if there's no option to ignore formatting/whitespace differences. 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 JSON input, large files, memory constraints, 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. Dark/Light theme support 2. JSON schema validation 3. Export options to different formats). 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 JSON parsers used) 2. Function modules unrelated to the core JSON tools (e.g., a built-in web browser) 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 UI/business logic/data processing layers), error handling quality, 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 macOS design standards?",
+      "description": "Evaluate whether the design follows macOS design principles: 1) Native-looking controls and interaction patterns 2) Proper spacing and alignment following Apple's Human Interface Guidelines 3) Professional typography with system font usage. Deduct 3 points for each non-native UI element, 5 points for layouts that don't adapt to window resizing, and 5 points for inconsistent visual hierarchy. 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 feedback for JSON formatting operations 2) Smooth transitions between different tool views 3) Efficient handling of large JSON documents without UI freezing. Deduct 5 points for operations without visual feedback, 5 points for UI freezes during JSON processing, and 3 points for jarring transitions between application states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "hard"
+}

package/library/utility_tools-daily_office_tasks/electron-vue-secure-dual-window-communication.json

@@ -0,0 +1,68 @@
+{
+  "index": 715,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable. Regarding an electron+vue dual-window program:\n1. Ensure the main window can send messages to the second window.\n2. Ensure it can run on Windows 7.\n3. Ensure secure communication between the main thread and renderer thread.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the dual-window implementation in Electron correctly structured?",
+      "description": "Examine if the code properly creates and manages two separate BrowserWindow instances. Check that window creation includes proper configuration options (width, height, webPreferences, etc.). Verify that both windows load the appropriate Vue components/pages. Score 0 if only one window is implemented, 5 if basic window creation exists but lacks proper configuration, and 10 if dual windows are fully implemented with appropriate lifecycle management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is cross-window communication properly implemented?",
+      "description": "Verify that the main window can send messages to the second window using appropriate IPC mechanisms. Check for implementation of either BrowserWindow.webContents.send() or ipcRenderer/webContents communication patterns. Ensure messages are properly formatted and include error handling. Deduct 5 points if communication is one-way only, 3 points if message acknowledgment is missing, and 2 points if error handling is inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is Windows 7 compatibility ensured?",
+      "description": "Check if the code specifies an Electron version compatible with Windows 7 (typically Electron ≤12). Verify that no APIs or features exclusive to newer OS versions are used. Check for proper polyfills and fallbacks. Look for explicit testing configurations for Windows 7. Deduct 5 points if incompatible Electron version is specified, 3 points if Windows 7-incompatible APIs are used without fallbacks, and 5 points if no compatibility considerations exist at all. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the IPC security implementation robust?",
+      "description": "Evaluate if the code implements secure communication between main and renderer processes. Check for proper use of contextIsolation, nodeIntegration (set to false), preload scripts with exposed APIs, and message validation. Verify data sanitization before processing. Score 0 if security basics are ignored, 5 if basic security measures exist but with vulnerabilities, and 10 if comprehensive security practices are implemented including input validation and context isolation.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as window closure during communication, IPC message timeout, process crashes, 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. Window state persistence between sessions 2. Customizable IPC timeout handling 3. Drag-and-drop between windows 4. Automatic window arrangement). 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 IPC functions 2. Unnecessary window creation/management code 3. Excessive event listeners or communication channels that could lead to memory leaks. 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 window management, IPC handling, and Vue components), unit test coverage for IPC messages, and build process automation for both development and production. 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) IPC response time ≤ 100ms 2) Window opening/closing animations controlled between 300-500ms 3) Clear visual feedback for cross-window operations. Deduct 5 points for each operation without feedback, 3 points for laggy window transitions, and 5 points for unclear indication of which window has focus. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "easy"
+}

package/library/utility_tools-daily_office_tasks/electronic-signature-plugin-canvas.json

@@ -0,0 +1,68 @@
+{
+  "index": 284,
+  "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. How can one write an electronic signature plugin using canvas?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core signature capture mechanism fully implemented?",
+      "description": "Check if the code implements proper mouse/touch event handling for signature capture, including start, move, and end events. Verify smooth line drawing with proper point interpolation instead of just connecting dots. 10 points for complete implementation with pressure sensitivity support, 5 points for basic implementation, 0 points if core functionality is missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the canvas properly initialized and configured?",
+      "description": "Evaluate if the canvas is properly initialized with correct dimensions, resolution handling for different devices (using device pixel ratio), and appropriate line styles (width, color, cap style). Check if the canvas has proper clearing mechanisms and initial state. 10 points for perfect configuration with responsive sizing, 5 points if basic configuration only, 0 points for improper setup.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are signature export options comprehensive?",
+      "description": "Review whether the plugin provides multiple export formats (PNG, JPEG, SVG, base64 encoding) with configurable options like background transparency, quality settings, and dimension control. Check if data URL generation works correctly. 10 points if all major formats with options are supported, 5 points for basic export, 0 points if export is not implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete signature validation system?",
+      "description": "Assess if the plugin includes signature validation features such as minimum stroke count, drawing area coverage percentage, or time-based validity checks. Verify if appropriate feedback is provided when signatures don't meet requirements. 10 points for comprehensive validation system, 5 points for basic checks, 0 points if validation is missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser compatibility issues, touch/mouse event differences, canvas context loss recovery, etc.) and provide fallbacks 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. Line smoothing algorithms 2. Undo/redo functionality 3. Signature replay/animation capability 4. Automatic signature positioning/scaling). 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 event listeners or drawing functions 2. Unnecessary canvas redraws that affect performance 3. Over-complicated algorithms for simple tasks. 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 drawing logic/UI/data processing layers), encapsulation as a proper plugin/component, and configuration options. Deduct 5 points if global namespace pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the plugin lacks proper documentation or API reference. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the signature pad design follows modern interface principles: 1) Clean, bordered signature area with visual feedback 2) Clear indication of active state and boundaries 3) Professional styling consistent with form elements. Deduct 3 points for poor visual indication of the signature area, 5 points for inconsistent styling with surrounding form elements, and 5 points for lack of visual feedback during signing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the drawing experience feels natural and responsive: 1) Line rendering delay ≤ 16ms (60fps) 2) No visible lag between pen/mouse movement and line appearance 3) Proper handling of fast movements without skipping. Deduct 5 points for noticeable lag during drawing, 3 points for stroke discontinuity during fast movements, and 5 points for poor mobile touch experience. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "medium"
+}

package/library/utility_tools-daily_office_tasks/email-template-generator-with-drag-and-drop.json

@@ -0,0 +1,68 @@
+{
+  "index": 556,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Ensure the code you generate is executable for demonstration. ======== ROLE ========\nYou are an experienced code expert. I am providing you with a software development requirement description and asking you to generate project code according to these requirements. Strictly follow the rules to help users generate complete project code that is fully commented in simple, easy-to-understand language, without outputting anything else.\n\n======== OUTPUT RULES ========\n1. Always generate complete, runnable project code, ensuring the project is fully executable\n2. Make sure all code files you output are complete, don't omit any code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot run or contains errors, regenerate it\n4. If the requirements involve external API access or user data (images, videos, audio, etc.), please provide simulated data\n\n======== PROJECT REQUIREMENTS ========\nBuild an email template generator where users can design email templates by dragging and dropping components, supporting the addition of text, images, buttons and other elements, with preview and HTML code export functionality.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the drag-and-drop component system fully implemented?",
+      "description": "Review whether the code accurately implements a drag-and-drop interface using HTML5 Drag API or touch events, including component palette, drop zones, visual feedback during dragging, and collision detection. Check if it supports dragging text blocks, image components, button elements, and layout containers. Score 0 if basic drag-drop is not functional, 5 if only simple element dragging works, and 10 if advanced features like nested dropping, snap-to-grid, and multi-selection are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are comprehensive email template components provided?",
+      "description": "Evaluate whether the system includes essential email components: text blocks (with rich text editing), image elements (with upload/URL input), buttons (with customizable styling), dividers, spacers, social media icons, and layout containers (columns, rows). Each component should have configurable properties (fonts, colors, spacing, alignment). Deduct 3 points for each missing essential component type, and 2 points if component property panels lack sufficient customization options. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the real-time preview system accurately implemented?",
+      "description": "Check whether the preview functionality provides accurate email rendering across different email clients (Gmail, Outlook, Apple Mail simulation). The preview should update in real-time as users modify components, support both desktop and mobile views, and handle responsive email layouts correctly. Deduct 5 points if preview doesn't match actual email output, 3 points if mobile responsiveness is missing, and 2 points if preview loading takes over 500ms. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is HTML code export functionality complete and standards-compliant?",
+      "description": "Assess whether the HTML export generates clean, email-client-compatible code using table-based layouts, inline CSS, and proper DOCTYPE declarations. The exported code should include fallbacks for unsupported CSS properties, proper encoding, and be optimized for email delivery. Check if export includes both HTML and plain-text versions. Deduct 5 points if exported HTML fails in major email clients, 3 points if code is not minified/optimized, and 2 points if no plain-text alternative is provided. 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 image URLs, oversized file uploads, browser compatibility issues, drag-drop edge cases, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-powered content suggestions 2. Template version history with branching 3. Collaborative editing with real-time cursors 4. A/B testing template variants 5. Integration with stock photo APIs). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple image upload handlers coexisting) 2. Function modules unrelated to email design (e.g., a built-in CRM system) 3. Fancy effects that affect performance (e.g., heavy 3D animations on drag). 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 drag-drop logic/component rendering/export functionality), 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) 4) Clear visual hierarchy between component palette, canvas, and property panels. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic panel 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) Drag feedback appears within ≤ 100ms 2) Component transitions controlled between 300-500ms 3) Clear visual indicators for drop zones and selection states 4) Smooth scrolling and panning in the canvas area. Deduct 5 points for each operation without visual feedback, 3 points for jerky drag animations, and 5 points if component selection states are unclear. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "hard"
+}

package/library/utility_tools-daily_office_tasks/excel-data-import-tool-html.json

@@ -0,0 +1,68 @@
+{
+  "index": 1792,
+  "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. Design an Excel data import tool, with all code encapsulated in a single HTML file.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "File Upload and Parsing Functionality",
+      "description": "Evaluate whether the code implements comprehensive Excel file upload and parsing functionality. Check for support of multiple Excel formats (XLSX, XLS, CSV), proper error handling for invalid files, and the ability to handle large files without browser freezing through techniques like streaming or web workers.Score 0 if file upload or parsing is not implemented, 5 if only basic parsing of one format is supported, and 10 if multiple formats are supported with robust handling of different scenarios including large files.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Data Preview and Validation",
+      "description": "Assess if the tool provides an interactive preview of the imported data with column type detection and validation capabilities. Check for the ability to preview data before importing, highlight potential data issues (like format inconsistencies or missing values), and options for configuring how to handle validation errors.Deduct 5 points if preview functionality is missing, 3 points if validation is limited or non-existent. Give 10 points if both comprehensive preview and validation features are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Data Transformation Options",
+      "description": "Examine whether the code offers data transformation capabilities such as column mapping, data type conversion, filtering options, and basic transformations before final import. Look for the ability to select/deselect columns, rename fields, and apply formulaic transformations.Award 0 points if no transformation features exist, 5 points for basic column selection/mapping, and 10 points for comprehensive transformation features including data type conversion and custom transformations.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Export/Save Functionality",
+      "description": "Evaluate if the tool provides options to export the processed data in different formats (JSON, CSV, etc.) or save/persist the data in some way (localStorage, download, etc.). Check for the ability to customize export options and handle large datasets efficiently.Score 0 if export functionality is missing, 5 if basic export to a single format is supported, and 10 if multiple export formats with customization options are available.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Code Robustness",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed Excel files, memory limitations, unsupported features) 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": "Innovative Features",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Column statistics and data profiling 2. Smart column type detection 3. Template-based import configurations).Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Feature Relevance and Conciseness",
+      "description": "Strictly check three types of redundancy: 1. Redundant libraries or dependencies for the same functionality 2. Feature modules unrelated to Excel import 3. Over-engineered components that complicate the solution unnecessarily.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": "Engineering Quality",
+      "description": "Review modular design (such as separating data processing/UI/storage concerns), code organization, and whether the solution is properly encapsulated in a single HTML file as required.Deduct 5 points if global namespace pollution is found or proper design patterns are not used; deduct 5 points if the code is difficult to maintain or extend; deduct 5 points if the solution is not properly encapsulated in a single HTML file. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Interface Design Quality",
+      "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": "Dynamic Interaction Quality",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Clear feedback during file processing 2) Progress indicators for long operations 3) Intuitive drag-and-drop functionality if implemented.Deduct 5 points for each operation without feedback, 3 points for sluggish UI during file processing, 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": "medium"
+}

package/library/utility_tools-daily_office_tasks/excel-file-upload-split-download.json

@@ -0,0 +1,68 @@
+{
+  "index": 1115,
+  "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. Please act as a web design expert and help me design a button for uploading Excel files. After uploading a file, provide a selection box that identifies field names from the user's Excel file, as these will be the basis for splitting the file in the next step.\n\nThen, when the user clicks the \"Split into separate workbooks\" button, it should split the uploaded Excel workbook according to the user-specified field. After completion, generate a download link for the folder containing the split files for easy downloading from the webpage. Please use HTML language.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Excel file upload functionality fully implemented?",
+      "description": "Review whether the code correctly implements file upload validation, file format checking (.xlsx, .xls, .csv), file size limits, and proper error handling for corrupted files. Check if the upload progress indicator and drag-and-drop functionality are included. Score 0 if basic upload is not working, 5 if only basic upload works without validation, and 10 if comprehensive upload with all validations and user feedback is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Excel field identification and selection mechanism properly implemented?",
+      "description": "Evaluate whether the code accurately parses Excel headers and presents them in an intuitive selection interface. Check if it handles merged cells, empty headers, duplicate field names, and provides preview of field data. The selection UI should support search, filtering, and clear visual indication of selected fields. Deduct 5 points if field parsing fails with complex Excel structures, 3 points if no data preview is provided. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the workbook splitting logic correctly implemented?",
+      "description": "Check whether the splitting algorithm properly groups rows based on selected field values, maintains original formatting, handles special characters in field values, and preserves formulas where applicable. Verify that empty groups are handled gracefully and that the splitting process provides progress feedback. Deduct 5 points if data integrity is compromised during splitting, 3 points if progress indication is missing. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the download system for split files properly designed?",
+      "description": "Evaluate whether the code generates properly named files, creates a downloadable ZIP archive, provides clear download links with file size information, and includes cleanup mechanisms for temporary files. Check if batch download is supported and download progress is shown. Deduct 5 points if file naming is inconsistent or unclear, 3 points if no cleanup mechanism exists for server storage. 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 Excel files, network interruption during upload, memory limitations with large files, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle these edge cases, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time preview of split results 2. Custom file naming templates 3. Data validation and cleaning options 4. Export format options beyond Excel 5. Batch processing of multiple files). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple file parsing libraries loaded simultaneously) 2. Function modules unrelated to Excel processing (e.g., built-in image editors) 3. Fancy effects that affect performance (e.g., complex animations during file 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 file processing/UI/download logic), error handling consistency, and code organization. Deduct 5 points if global state pollution is found or no proper separation of concerns; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if no proper memory management for large files. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching and consistent theme 2) Proper layout spacing and visual hierarchy 3) Clear typography and readable fonts 4) Intuitive workflow guidance 5) Responsive design for different screen sizes. Deduct 3 points for each cluttered visual element, 5 points for poor color contrast affecting readability, and 5 points for confusing user flow. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the interactions conform to user expectations: 1) Immediate feedback for file selection and upload 2) Progress indicators for long-running operations 3) Smooth transitions between workflow steps 4) Clear loading states and success/error messages 5) Responsive button states and hover effects. Deduct 5 points for each operation without proper feedback, 3 points for confusing loading states, and 5 points for poorly accessible interactive elements. Full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "medium"
+}

package/library/utility_tools-daily_office_tasks/generate-calendar-with-specific-work-pattern.json

@@ -0,0 +1,68 @@
+{
+  "index": 904,
+  "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 purposes. Starting from March 1st, taking 4 days off followed by 2 days of work, and continuing this pattern going forward, write HTML code to generate a calendar.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the calendar core functionality properly implemented?",
+      "description": "Evaluate if the HTML code correctly generates a calendar that marks days with the 4-days-off followed by 2-days-work pattern starting from March 1st. Check if the calendar properly distinguishes between 'off' and 'work' days using visual indicators. Score 0 if the pattern implementation is incorrect, 5 if basic pattern is implemented but with minor issues, and 10 if perfectly implemented with clear visual distinction between work and off days.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the calendar handle date calculations correctly?",
+      "description": "Review the accuracy of date calculations, including correct handling of different month lengths (28/29/30/31 days), proper weekday assignments, and seamless transition between months. The pattern must continue correctly across month boundaries. Deduct 3 points for each calculation error found. Check if leap years are handled properly when applicable. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there proper month navigation functionality?",
+      "description": "Assess whether the calendar allows users to navigate between months while maintaining the work/off pattern continuity. Check for previous/next month controls and proper state maintenance. Score 0 if navigation is absent, 5 if basic navigation exists but doesn't maintain pattern continuity, and 10 if navigation works flawlessly with pattern consistency across months.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the calendar's date range handling flexible?",
+      "description": "Evaluate if the calendar allows custom start dates other than March 1st and maintains the correct pattern from any given start date. Check if the code can dynamically adjust the pattern based on user-defined parameters. Score 0 if only hardcoded for March 1st, 5 if partially flexible, and 10 if fully customizable with proper pattern maintenance.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid dates, user input errors, etc.) and provide friendly error handling 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. Interactive tooltips showing work/off status 2. Pattern statistics showing monthly work/off distribution 3. Customizable pattern settings). 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 date calculation logic 2. Function modules unrelated to the calendar task 3. Fancy effects that affect performance unnecessarily. 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 calendar generation logic from display elements), code reusability, and maintainability. Deduct 5 points if global state pollution is found or proper functions 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 is difficult to maintain. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the calendar design follows modern design principles: 1) Harmonious color matching for work/off days (no more than 3 primary colors) 2) Proper layout spacing (grid cells properly sized and aligned) 3) Professional font system (date numbers clearly readable, headers properly emphasized). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic calendar 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 when navigating months 2) Smooth transitions between calendar views 3) Clear visual indication of the current date and pattern status. Deduct 5 points for each operation without feedback, 3 points for jarring transitions, and 5 points for confusing status indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "hard"
+}