@getollie/cli 0.0.1

package/library/utility_tools-daily_office_tasks/generate-family-annual-budget-table.json

@@ -0,0 +1,68 @@
+{
+  "index": 707,
+  "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. Please generate a family annual budget table.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the family budget table structure complete?",
+      "description": "Check if the code implements all necessary components of a family budget table: income section, expense categories (fixed/variable), savings allocation, and balance calculation. Score 0 if only basic structure exists, 5 if most components are included but lack detail, and 10 if comprehensive with monthly and annual breakdowns.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the data input and modification functionality implemented?",
+      "description": "Evaluate whether users can add, edit, and delete budget entries easily. Check for form validation (preventing negative values, incorrect date formats), input masks for currency, and proper error handling. Deduct 5 points if modification features are missing, 3 points if validation is incomplete. Full score requires responsive input handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are budget calculations and analysis features implemented?",
+      "description": "Review whether the code performs accurate calculations for totals, percentages, and variances between planned vs. actual spending. Check for monthly/yearly aggregations, category-based analysis, and trend visualization. Deduct 5 points if calculations contain errors, 3 points if analysis features are basic. Full implementation should include forecasting capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the budget table include data persistence features?",
+      "description": "Assess whether the code implements data saving functionality (localStorage, file export/import, or server-side storage). Check if the implementation includes backup options and data recovery. Deduct 5 points if data is lost on page refresh, 3 points if export options are limited. Full score requires seamless data persistence across sessions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, browser compatibility issues, incomplete data entries) 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. Visual spending patterns with charts 2. Budget health indicators/warnings 3. Financial goal tracking widgets). 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 calculation methods for the same metric) 2. Function modules unrelated to family budgeting (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., excessive animations on every cell update). 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/calculation logic), code reusability, and maintainability. Deduct 5 points if global variable 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 commenting 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 (appropriate use of colors for positive/negative values, categories) 2) Proper layout spacing (clear row/column structure, consistent padding) 3) Professional font system (legible numbers, appropriate emphasis on totals and headings). Deduct 3 points for cluttered tables, 5 points for poor color choices that hinder readability, and 5 points for inconsistent alignment of numerical values. 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 when entering budget figures 2) Smooth transitions when toggling between views (monthly/yearly) 3) Intuitive navigation between budget sections. Deduct 5 points for each operation without feedback, 3 points for lagging calculations with large datasets, and 5 points for unintuitive interaction patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "hard"
+}

package/library/utility_tools-daily_office_tasks/generate-roll-call-program-html-format.json

@@ -0,0 +1,68 @@
+{
+  "index": 1223,
+  "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 when possible. Generate a roll call program in HTML format.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the HTML document structure properly implemented?",
+      "description": "Check if the code includes a complete HTML5 document structure with <!DOCTYPE html>, <html>, <head>, and <body> tags. The <head> section should include proper meta tags, title, and CSS/JS references. Deduct 5 points if doctype is missing, 3 points for missing meta viewport tag, and 5 points for improper character encoding. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the roll call functionality fully implemented?",
+      "description": "Evaluate if the code includes core roll call features: 1) Adding names to a list, 2) Random selection mechanism, 3) Marking attendance status, and 4) Displaying results. Score 0 if none of these features exist, 5 if only basic name listing is implemented, and 10 if all four functionalities are properly implemented and work together.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there proper data management for the roll call system?",
+      "description": "Review if the program handles the roll call data appropriately, including: 1) Data structure for storing names and attendance status, 2) Persistence mechanism (local storage/session storage), 3) Data validation for inputs. Deduct 3 points if no validation exists, 5 points if there's no data persistence, and 3 points if the data structure is inefficient. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a user-friendly interface for managing attendance?",
+      "description": "Check if the interface includes: 1) Clear attendance status indicators, 2) Search/filter functionality, 3) Sorting options, and 4) Summary statistics (present/absent counts). Score 3 points for basic display only, 7 points for interactive controls without statistics, and 10 points for a complete management interface with all features.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as empty input, duplicate names, unexpected user actions) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Animation for random selection process, 2. Voice announcement of selected names, 3. Statistics visualization, 4. Timer for response window). 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 add names) 2. Function modules unrelated to roll call (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 UI/logic/data layers), code organization, and maintainability. Deduct 5 points if global variable pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation of concerns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during interaction, 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/gui-framework-function-switching.json

@@ -0,0 +1,68 @@
+{
+  "index": 241,
+  "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. Design a GUI framework that allows me to switch between functions, either through a dropdown menu or by displaying the functions directly in the menu bar, where clicking on a function switches to a different interface.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the GUI framework's core structure properly implemented?",
+      "description": "Evaluate whether the code implements a proper component-based architecture with clear separation between UI elements, event handling, and state management. Check if the framework includes proper component lifecycle management (creation, mounting, updating, destruction). Score 0 if there's no clear structure, 5 if basic structure exists but lacks cohesion, and 10 if the architecture follows best practices with proper encapsulation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the navigation/routing system functional and comprehensive?",
+      "description": "Review the implementation of the menu system (dropdown or menu bar) and page switching mechanism. Check if the code properly handles state preservation between page switches, supports nested routes if applicable, and provides visual feedback during navigation. Deduct 5 points if state is lost during navigation, 3 points if there's no transition feedback, and 5 points if routes cannot be bookmarked or deep-linked. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the framework extensible and configurable?",
+      "description": "Assess whether the framework allows easy addition of new functions/pages without modifying core code. Check if the menu system is data-driven rather than hardcoded. Verify that styling, layout, and behaviors can be configured. Score 0 if adding new functions requires modifying core code, 5 if basic extensibility exists but with limitations, and 10 if the framework supports plugin architecture or well-defined extension points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper event handling and state management?",
+      "description": "Evaluate the event system for handling user interactions and the state management approach. Check if the code implements proper event delegation, avoids memory leaks, and efficiently updates only changed parts of the UI. Deduct 3 points if event listeners aren't properly managed, 4 points if global state is overused or poorly organized, and 3 points if the UI doesn't reflect state changes reactively. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, missing configurations, asynchronous operation failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Animated transitions between views 2. Keyboard shortcut navigation 3. Theme switching capability 4. Responsive design adaptation). 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 navigation systems coexisting) 2. Function modules unrelated to the GUI framework (e.g., unnecessary third-party integrations) 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 model/view/controller components), code organization, naming conventions, and documentation quality. Deduct 5 points if global namespace 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 documentation or comments are insufficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast menu switching, 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/hbuilder-apk-document-reader-text-to-speech.json

@@ -0,0 +1,68 @@
+{
+  "index": 271,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for demonstration. Please help me create an Android APK based on HBuilder that can achieve the following: import PDF and Word documents, then read the entire text aloud according to user instructions, or read specific paragraphs or time segments as specified by the user. The reading function should support selection between male and female voices, with multiple timbre options available. Your final output should be code that can be directly compiled and executed. Additionally, if certain features require plugins, please help me choose free options rather than paid ones.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Does the solution properly implement document import functionality for PDF and Word files?",
+      "description": "Check if the code includes complete implementation for importing both PDF and Word documents using appropriate APIs or plugins. The solution should handle file selection from device storage, handle permissions properly, and support both file formats with proper error handling. Verify that the imported documents maintain their formatting and structure.0 points if document importing is not implemented, 5 points if only one format is supported or if implementation has significant limitations, 10 points for complete implementation supporting both formats with proper error handling and user feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is text extraction from documents properly implemented?",
+      "description": "Evaluate whether the code correctly extracts text content from imported documents. This should include handling of different document structures, proper text flow preservation, and support for special characters and formatting. Text extraction should work with both simple and complex document layouts.0 points if text extraction is missing, 4 points if only basic extraction is implemented with formatting issues, 7 points if extraction works well for most documents but has some limitations, 10 points for robust extraction that handles various document complexities.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the text-to-speech (TTS) functionality fully implemented with voice options?",
+      "description": "Check if the code implements complete TTS functionality with support for both male and female voices and multiple timbre options. Verify that the TTS engine initialization is properly handled, and that voice selection options are properly presented to the user.0 points if TTS is not implemented, 4 points if basic TTS works but without voice options, 7 points if male/female selection is available but without multiple timbres, 10 points for complete implementation with all required voice options and proper timbre selection UI.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the application support selective reading of paragraphs and time segments?",
+      "description": "Evaluate whether users can select specific paragraphs or time segments for reading. This includes implementation of text segmentation, UI for paragraph selection, time segment definition, and proper control mechanisms for the TTS engine to read only selected portions.0 points if selective reading is not implemented, 5 points if only paragraph selection OR time segment selection is implemented, 8 points if both are implemented but with usability issues, 10 points for complete implementation with intuitive user controls.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed documents, unsupported content, TTS engine failures, etc.) and provide friendly error prompts or recovery mechanisms. Check for proper exception handling, input validation, and graceful degradation.0 points if no exception handling exists, 5 points if basic error handling is implemented but lacks comprehensive coverage, 10 points if robust error handling covers all major failure scenarios with user-friendly messaging.",
+      "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. Reading speed adjustment 2. Bookmarking important paragraphs 3. Voice pitch/rate customization 4. Text highlighting during reading 5. Export spoken content as audio files).Add 2 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 TTS engines running in parallel) 2. Function modules unrelated to document reading (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., unnecessary animations).Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating document handling/TTS/UI layers), error handling coverage, and proper use of HBuilder capabilities. Check for code organization, commenting quality, and adherence to Android development 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 plugin integration is poorly implemented. 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 Android design principles: 1) Material Design guidelines compliance 2) Proper layout spacing and consistency 3) Professional typography (readable font sizes, proper contrast). Check for proper UI components for document viewing and controls.Deduct 3 points for each poor UI element implementation, 5 points for non-standard Android UI patterns, and 5 points for chaotic document/control layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the app provides smooth user experience: 1) Responsive controls for playback 2) Smooth document scrolling and navigation 3) Clear visual feedback for voice selection and reading progress 4) Appropriate loading indicators for document processing.Deduct 5 points for each operation without feedback, 3 points for laggy document navigation, and 5 points for hard-to-find TTS control functions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "medium"
+}

package/library/utility_tools-daily_office_tasks/html-ansi-decoder-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 426,
+  "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 whenever possible. Create an online ANSI decoder tool written in HTML.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the ANSI escape sequence parsing engine fully implemented?",
+      "description": "Review whether the code accurately implements ANSI escape sequence parsing through JavaScript, including color codes (3/4-bit, 8-bit, 24-bit RGB), text formatting (bold, italic, underline, strikethrough), cursor positioning, and screen clearing commands. Score 0 if core parsing logic is missing, 5 if only basic color codes are supported, and 10 if comprehensive ANSI standards (including SGR, cursor control, and erase sequences) are fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the real-time decoding and rendering functionality implemented?",
+      "description": "Check whether the tool provides real-time input processing with immediate visual output rendering. Evaluate if the rendering engine correctly converts ANSI sequences to HTML/CSS equivalents with proper color mapping and text styling. Deduct 5 points if rendering has noticeable lag (>200ms), 3 points if color accuracy is poor, and 5 points if malformed sequences crash the parser. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is comprehensive input/output handling designed with format support?",
+      "description": "Evaluate whether the tool supports multiple input methods (text paste, file upload, drag-and-drop) and output formats (HTML export, plain text, image capture). Check if proper encoding handling (UTF-8, ASCII) is implemented and if large file processing is optimized. Deduct 5 points if file upload is missing, 3 points if no export functionality, and 5 points if encoding issues cause corruption. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the user interface intuitive with proper control features?",
+      "description": "Check whether the interface includes essential controls like clear/reset buttons, theme switching (dark/light mode), font size adjustment, and preview pane resizing. Evaluate if proper input validation and user guidance are provided. Deduct 5 points if basic controls are missing, 3 points if no responsive design, and 5 points if accessibility features are absent. Give 10 points if fully implemented with keyboard shortcuts.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed ANSI sequences, oversized input, memory leaks from continuous processing, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully handle edge cases like nested sequences and incomplete escape codes, 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. Syntax highlighting for ANSI codes in input 2. Animated sequence demonstration mode 3. Color palette extraction from decoded content 4. Sequence builder/generator tool). 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 parsing functions (e.g., multiple color conversion methods) 2. Function modules unrelated to ANSI decoding (e.g., built-in text editor with spell check) 3. Fancy effects that affect performance (e.g., rainbow animations during processing). Deduct 3 points for each redundancy found, and directly deduct 10 points if core decoding 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 parser/renderer/UI layers), proper error handling, and code organization. Deduct 5 points if global state pollution is found or no clear separation of concerns; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if no input sanitization or XSS protection. 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 with proper contrast ratios 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional typography (monospace fonts for code, readable sizes ≥ 14px). Deduct 3 points for each crowded visual element, 5 points for poor color contrast affecting readability, and 5 points for chaotic 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) Input response delay ≤ 100ms 2) Smooth scrolling and resizing animations 3) Clear visual feedback for all interactions 4) Proper loading states for file processing. Deduct 5 points for each operation without feedback, 3 points for janky animations during large content processing, and 5 points for unclear UI states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "hard"
+}

package/library/utility_tools-daily_office_tasks/html-browser-python-compiler.json

@@ -0,0 +1,68 @@
+{
+  "index": 1572,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that any code you generate is executable and demonstrable. Could you write HTML code for a Python programming compiler that can run in a browser? Understand? It should allow Python code input to be executed directly.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is a complete web-based Python compiler UI implemented?",
+      "description": "Evaluate whether the HTML code creates a proper editor interface with input area for Python code, execution button, and output display area. Check for syntax highlighting, line numbers, and proper spacing. Score 0 if the basic UI elements are missing, 5 if only basic elements are present without enhancements, and 10 if the interface is comprehensive with proper layout and editor features.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Python code execution functionality properly implemented?",
+      "description": "Check whether the solution uses appropriate methods for browser-based Python execution (e.g., Pyodide, Skulpt, Brython, or appropriate backend integration). Verify that the execution mechanism handles standard input/output properly and can run Python code as expected. Deduct 5 points if execution is limited to basic statements, and 8 points if execution relies on unsecured eval() methods. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the implementation handle Python errors and exceptions appropriately?",
+      "description": "Assess whether Python runtime errors and syntax errors are properly caught, formatted, and displayed to users. The error reporting should include line numbers, error types, and descriptive messages. Deduct 5 points if errors crash the compiler instead of being gracefully handled, and 3 points if error messages are technical and not user-friendly. Full score of 10 points requires comprehensive error handling with clear user feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there support for standard Python libraries and imports?",
+      "description": "Evaluate whether the implementation supports importing standard Python libraries or provides workarounds. Check if common modules like math, random, datetime, etc. are available. Score 0 if no library support exists, 5 points if only basic/limited library support is provided, and 10 points if comprehensive library support is implemented with clear documentation about available modules.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as very large code inputs, infinite loops, memory-intensive operations, 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. Code autocompletion 2. Theme switching 3. Code sharing capability 4. Code examples/templates 5. Visualization of Python execution). Add 2 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 execution methods) 2. Function modules unrelated to Python compilation (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., unnecessary animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating editor/execution/display components), 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 there's no clear separation of concerns between UI and execution 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 (editor font is monospace, 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) Execution feedback delay ≤ 100ms 2) Loading indicators for long-running code 3) Clear visual focus guidance during code editing and execution. Deduct 5 points for each operation without feedback, 3 points for lack of proper loading states during execution, 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/html-css-convert-word-document-to-webpage.json

@@ -0,0 +1,68 @@
+{
+  "index": 1314,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate, professional responses. Make sure that the code you generate is executable for demonstration purposes. Use HTML/CSS to convert Word document content into a webpage with identical formatting.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the document structure parsing and conversion fully implemented?",
+      "description": "Review whether the code accurately parses Word document structure (headings, paragraphs, lists, tables) and converts them to corresponding HTML semantic elements. Check if it supports nested structures like multi-level lists and complex table layouts. Score 0 if basic document parsing is missing, 5 if only simple text and paragraphs are converted, and 10 if complex document structures including tables, lists, and headers are fully supported.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the text formatting preservation accurate?",
+      "description": "Evaluate whether text formatting (bold, italic, underline, font family, font size, text color, background color, strikethrough) is accurately converted from Word to CSS. Check if character-level formatting within paragraphs is maintained. Deduct 3 points for each major formatting type that's not preserved. Deduct 5 points if inline formatting is lost. Full score requires pixel-perfect text formatting reproduction.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the layout and spacing faithfully reproduced?",
+      "description": "Check whether page margins, paragraph spacing, line height, indentation, and alignment are accurately converted to CSS. Evaluate if the webpage layout matches the Word document's visual spacing. Deduct 5 points if paragraph spacing differs significantly, 3 points if margins are incorrect, and 5 points if text alignment is not preserved. Full score requires exact layout reproduction.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are media elements and special content properly handled?",
+      "description": "Assess whether images, embedded objects, hyperlinks, and special characters are correctly extracted and displayed in HTML. Check if image positioning, sizing, and text wrapping are maintained. Deduct 5 points if images are not displayed, 3 points if hyperlinks are broken, and 5 points if special formatting like text boxes or shapes are missing. Full score requires complete media element preservation.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as corrupted Word files, unsupported formatting, missing fonts, large file sizes, etc.) and provide friendly error prompts or fallback 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 table of contents navigation 2. Side-by-side comparison with original document 3. Responsive design for mobile viewing 4. Print-optimized CSS). 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 conversion functions (e.g., multiple CSS generation methods coexisting) 2. Function modules unrelated to document conversion (e.g., built-in text editor) 3. Excessive visual effects that don't improve readability. Deduct 3 points for each redundancy found, and directly deduct 10 points if core conversion 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 parsing logic/CSS generation/HTML rendering), code organization, and error handling structure. 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 parsing logic is tightly coupled with presentation logic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the converted webpage maintains professional document appearance: 1) Consistent typography hierarchy 2) Proper whitespace and reading flow 3) Cross-browser font rendering compatibility 4) Print-friendly styling. Deduct 3 points for each typography inconsistency, 5 points for poor readability due to spacing issues, and 5 points if the webpage looks significantly different from the original document. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the rendering performance optimized and scalable?",
+      "description": "Judge whether the conversion handles large documents efficiently: 1) CSS optimization to avoid redundant styles 2) Proper HTML structure without excessive nesting 3) Efficient handling of complex tables and lists 4) Reasonable loading time for large documents. Deduct 5 points for each performance bottleneck, 3 points for bloated CSS output, and 5 points if the page becomes unresponsive with complex documents. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "hard"
+}

package/library/utility_tools-daily_office_tasks/html-random-name-selector-with-excel-import.json

@@ -0,0 +1,68 @@
+{
+  "index": 327,
+  "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 an HTML webpage that implements a random name selection function, supporting the import of a name list through local Excel file upload. Design a beautiful interface with three buttons: start, pause, and reset.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core random name selection functionality fully implemented?",
+      "description": "Review whether the code accurately implements the random name selection algorithm, including proper randomization, no repetition of selected names (unless reset), and visual indication of the currently selected name. Score 0 if the selection logic is not implemented, 5 if basic selection exists but has flaws, and 10 if the selection is truly random with proper visual feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Excel file import functionality properly implemented?",
+      "description": "Check whether the code can correctly parse Excel files (.xlsx/.xls), extract name data from different sheet structures, handle various Excel format issues (merged cells, empty cells, etc.), and provide error feedback for invalid files. Deduct 5 points if only CSV is supported but not Excel, 3 points if the parsing is buggy, and 2 points if there's no validation feedback. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the three required control buttons (start, pause, reset) implemented with proper functionality?",
+      "description": "Evaluate whether the three buttons work as expected: start initiates the selection animation, pause freezes the current selection, and reset clears the selection history. Each button should have appropriate state management (disabled when relevant) and provide visual feedback when clicked. Deduct 3 points per missing or non-functional button. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper state management for the name selection process?",
+      "description": "Check if the application maintains proper states for: loaded names list, currently selected name, selection history, and application status (idle/selecting/paused). The state transitions should be logical and bug-free (e.g., can't pause if not started). Deduct 3 points for each state management flaw, and 5 points if the selection history is not maintained. 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 empty Excel files, unsupported file formats, rapid button clicking, 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. Animation effects during name selection 2. Sound effects for selection events 3. History log of previously selected names 4. Export of selection results). 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 select names) 2. Function modules unrelated to name selection (e.g., unneeded analytics) 3. Fancy effects that affect performance (e.g., excessive animations that slow down selection). 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/data processing/event handling), code organization, use of appropriate design patterns, and defensive programming techniques. 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 isn't properly commented or documented. 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 name display vs. controls. 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) Name selection animation is visually pleasing but not distracting 3) Clear visual indication when a name is finally selected. Deduct 5 points for each operation without feedback, 3 points for jarring or too-fast animations during selection, and 5 points for unclear indication of the selected name. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Daily Office Tasks",
+  "difficulty": "easy"
+}