@getollie/cli 0.0.4 → 0.2.0

package/library/utility_tools-daily_office_tasks/password-generation-management-tool.json

@@ -1,68 +0,0 @@
-{
-  "index": 636,
-  "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. Implement a password generation and management tool where users can set the password length and include specific character types (such as letters, numbers, special characters) to generate random passwords that meet the requirements. The tool should support saving generated passwords locally and allow editing and deleting operations on the saved passwords.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the password generation functionality fully implemented?",
-      "description": "Review whether the code accurately implements core password generation with customizable options: length selection, character type inclusion (uppercase letters, lowercase letters, numbers, special characters). Score 0 if the core functionality is missing, 5 if only basic generation exists without all options, and 10 if all customization options are fully implemented with proper validation (e.g., minimum length checks, at least one character type selected).",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the password strength evaluation implemented?",
-      "description": "Check whether the code includes password strength evaluation using industry standards (entropy calculation, character diversity analysis, common pattern detection). Deduct 3 points if only basic length-based evaluation is used, 5 points if no evaluation exists. Full score requires visual strength indicators (color bars or descriptive text) and specific improvement suggestions for weak passwords.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the password storage and management system properly implemented?",
-      "description": "Evaluate the implementation of password saving, editing, and deleting functionality. Assess whether passwords are stored with associated metadata (website/service name, username, creation date). Deduct 5 points if any core CRUD operation is missing, 3 points if passwords are stored without encryption. The full score requires proper data persistence (localStorage, IndexedDB, or File API) with data integrity checks.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a secure clipboard interaction mechanism?",
-      "description": "Check whether the tool provides convenient copy-to-clipboard functionality with appropriate security measures. Evaluate whether the clipboard content is automatically cleared after a timeout period, and if visual feedback is provided on successful copy. Deduct 5 points if copy functionality is missing, 3 points if no feedback is provided, and 3 points if no auto-clear security feature exists.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, storage access failures, concurrent operations) 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. Password history tracking 2. Password expiration notifications 3. Breach detection API integration 4. Master password protection). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple storage mechanisms active simultaneously) 2. Function modules unrelated to password management (e.g., built-in calendar) 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/storage layers), input validation thoroughness, and code reusability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments explaining complex logic or security considerations. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Daily Office Tasks",
-  "difficulty": "easy"
-}

package/library/utility_tools-daily_office_tasks/pdf-text-extraction-tool.json

@@ -1,68 +0,0 @@
-{
-  "index": 671,
-  "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. Implement a PDF text extraction tool that allows users to upload PDF files, extract text content, perform simple editing on the content, and save it in new file formats (txt, docx, etc.).",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the PDF upload and parsing functionality correctly implemented?",
-      "description": "• Check if the code properly handles PDF file uploads with validation for file types and size limits. Verify if a reliable PDF parsing library (like pdf.js, pdfminer, PyPDF2, etc.) is correctly implemented and properly handles both text-based and scanned PDFs (with OCR if applicable). Deduct 5 points if only basic PDF handling is implemented without error handling, 3 points if no validation exists. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the text extraction feature complete and accurate?",
-      "description": "• Evaluate the accuracy and completeness of text extraction, including proper handling of formatting, special characters, multi-column layouts, and embedded fonts. Check if the extraction preserves paragraph structure, headings, and lists. Score 0 if extraction fails on common PDFs, 5 if basic extraction works but loses formatting, and 10 if extraction is comprehensive and preserves document structure.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the text editing functionality properly implemented?",
-      "description": "• Assess whether the code includes a complete set of text editing features (search/replace, formatting options, paragraph management, etc.) with proper text selection and cursor positioning. Check if changes are tracked properly and can be undone/redone. Deduct 3 points if basic formatting is missing, 5 points if undo/redo is not implemented, and give 10 points for comprehensive editing capabilities.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the export to multiple file formats correctly implemented?",
-      "description": "• Verify if the code supports exporting to various formats (txt, docx, rtf, html, etc.) with appropriate libraries and maintains formatting during conversion. Check if metadata and document properties are preserved where applicable. Deduct 3 points for each missing major format, 5 points if formatting is lost during export. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "• Evaluate whether the code can handle common abnormal situations (such as corrupted PDFs, memory-intensive large files, network interruption during upload/download, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "• Check whether the code includes surprise features that enhance the experience (e.g., 1. Batch processing of multiple PDFs 2. Advanced text analysis like keyword extraction 3. PDF annotation preservation 4. Table detection and conversion to spreadsheet 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 text processing engines) 2. Function modules unrelated to PDF handling or text editing (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., unnecessary animations during processing). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "• Review modular design (such as separating upload/parsing/editing/export components), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "• Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "• Judge whether the dynamic effects conform to human perception characteristics: 1) Progress indicators for long-running PDF operations 2) Transition animation duration controlled between 300-500ms 3) Clear visual feedback for text selection and editing actions. Deduct 5 points for operations without loading indicators during processing, 3 points for laggy text editing experience, 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/ping-pong-score-counter-html-mobile-devices.json

@@ -1,68 +0,0 @@
-{
-  "index": 1097,
-  "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. Create a ping pong score counter in HTML that can run on mobile devices.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the ping pong score counter functionality fully implemented?",
-      "description": "Check if the code accurately implements the basic score counting mechanism, including incrementing scores for each player, correctly identifying the serving player, and handling game points according to standard ping pong rules (first to 11 with 2-point lead). Score 0 if the core functionality is missing, 5 if only basic scoring is implemented, and 10 if it includes game/match logic with proper rules enforcement.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the mobile device compatibility properly implemented?",
-      "description": "Evaluate whether the code includes mobile-specific features like responsive design (using viewport meta tags, media queries, flexible units), touch event handling (touchstart/touchend instead of just click events), and prevents zooming/scrolling issues during play. Deduct 3 points if responsive design is missing, 4 points if touch events aren't properly implemented, and 3 points if mobile gestures aren't prevented when needed. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the interface provide clear visual feedback for score changes?",
-      "description": "Check if score increments are visually acknowledged through animations, color changes, or other feedback mechanisms. The current server should be clearly indicated and switch automatically according to the rules. Deduct 5 points if score changes have no visual feedback, 3 points if the serving player isn't clearly indicated, and 2 points if there's no visual difference between regular points and game points. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there state persistence or match history functionality?",
-      "description": "Evaluate whether the application can save the current state (using localStorage/sessionStorage), allow for game resets without page reload, and potentially track match history. Deduct 5 points if there's no way to persist state between page refreshes, 3 points if the reset functionality requires page reload, and 2 points if there's no match history tracking. 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 rapid consecutive tapping, device rotation, browser back navigation, accidentally closing the browser, 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. Sound effects for points/games 2. Vibration feedback on mobile 3. Voice announcements of scores 4. Customizable player names). 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 scoring systems coexisting) 2. Function modules unrelated to ping pong scoring (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow down score updates). 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/state management), code maintainability, and performance optimization. Deduct 5 points if global state pollution is found; deduct 3 points if the code duplication rate is too high; deduct 2 points if event listeners aren't properly managed (potential memory leaks). 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) Score update feedback delay ≤ 100ms 2) Button touch area ≥ 44x44px for easy tapping 3) Clear visual distinction between interactive and non-interactive elements. Deduct 5 points for each operation without feedback, 3 points for laggy animations, and 5 points for hard-to-tap buttons on mobile. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Daily Office Tasks",
-  "difficulty": "easy"
-}

package/library/utility_tools-daily_office_tasks/read-excel-display-data-html.json

@@ -1,68 +0,0 @@
-{
-  "index": 923,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Read excel file and display data, HTML code",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Excel file reading functionality properly implemented?",
-      "description": "Check if the code correctly implements file input for Excel files (.xlsx, .xls, .csv) and handles different Excel formats. Score 0 if no file loading is implemented, 5 if only basic file reading is done, and 10 if the implementation handles various Excel formats with robust error checking for file corruption or format issues.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the data parsing and extraction logic complete?",
-      "description": "Verify that the code correctly extracts data from Excel sheets, handling different data types (text, numbers, dates, formulas), empty cells, and merged cells. Deduct 3 points if certain data types aren't properly handled, 5 points if merged cells cause issues, and 3 points if there's no error handling for invalid data. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the HTML display of Excel data implemented effectively?",
-      "description": "Evaluate whether the HTML representation maintains the original Excel structure (tables, rows, columns) with appropriate styling that resembles Excel's visual layout. Check if column widths, row heights, cell alignments, and text formatting are preserved. Score 0 if data is just dumped without structure, 5 if basic table structure exists, and 10 if the display closely resembles Excel's appearance.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are interactive data manipulation features implemented?",
-      "description": "Check if the HTML implementation includes features like sorting, filtering, searching, or basic cell editing. Deduct 3 points for each missing core feature (sorting, filtering, search). Award full 10 points only if the implementation allows for data manipulation comparable to basic Excel functionality.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid Excel files, large datasets, unexpected data formats, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Live data visualization options 2. Excel formula support in the HTML view 3. Multi-sheet navigation tabs). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant libraries for similar functions (e.g., multiple Excel parsers loaded) 2. Function modules unrelated to Excel data display (e.g., unnecessary animations) 3. Overly complex implementations that affect performance (e.g., excessive DOM manipulation). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating file loading/parsing/display logic), error handling coverage, and proper documentation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments explaining complex 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 data presentation principles: 1) Clean table styling with appropriate borders and spacing 2) Visual hierarchy that makes headers distinct from data 3) Consistent typography and alignment across the table. Deduct 3 points for cluttered visual presentation, 5 points for inconsistent styling that makes data hard to read, and 5 points for poor responsive design on different screen sizes. 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 user expectations: 1) File upload feedback is immediate 2) Large data sets load with progress indicators 3) Sorting/filtering operations complete within 300ms for standard datasets. Deduct 5 points for operations without loading indicators for large files, 3 points for jerky scrolling on large tables, and 5 points for unresponsiveness during data processing. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Daily Office Tasks",
-  "difficulty": "medium"
-}

package/library/utility_tools-daily_office_tasks/real-time-baseball-score-display-for-streaming.json

@@ -1,68 +0,0 @@
-{
-  "index": 400,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure that any code you generate is executable. Please help me create a small program for real-time baseball game score and situation display that can be used for live streaming on mobile Weibo and Douyin.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the baseball game scoreboard fully implemented?",
-      "description": "Review whether the code accurately implements essential baseball scoreboard elements including innings (top/bottom), runs, hits, errors, balls, strikes, outs, and current baserunners. Score 0 if core display elements are missing, 5 if basic scoring is implemented but lacking situation details, and 10 if the scoreboard includes all professional baseball statistics with proper layout and updates.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the real-time data update mechanism implemented?",
-      "description": "Check whether the code includes proper data fetching mechanism (WebSocket, polling or Server-Sent Events) with error handling and reconnection logic. Verify that updates are reflected immediately on the UI without manual refresh. Deduct 5 points if updates require manual intervention, 3 points if the update frequency is inappropriate (too slow >5s or too resource-intensive <1s), and 3 points if there's no loading state or error handling. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the mobile-first design properly implemented for Weibo and Douyin?",
-      "description": "Evaluate whether the UI is optimized for vertical mobile viewing (16:9 or 9:16 aspect ratios), respects platform-specific UI guidelines, and includes platform branding options. Check if the implementation uses responsive design principles with proper viewport settings. Deduct 5 points if the layout breaks on common mobile resolutions, 3 points if touch targets are smaller than 44x44px, and 5 points if the interface doesn't adapt to different orientations. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the baseball field visualization interactive and accurate?",
-      "description": "Assess whether the code provides a clear visual representation of the baseball diamond with accurate baserunner positions, defensive positioning options, and play result animations. Check if the field visualization updates correctly based on game events. Deduct 5 points if the baseball diamond visualization is static or poorly implemented, 3 points if baserunner indicators are unclear, and 5 points if there are no visual cues for recent plays. 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 data feed interruptions, malformed inputs, network latency, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully handle edge cases like incomplete game data, mid-game reconnections, and unexpected server responses, 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. Pitch trajectory visualization 2. Player statistics pop-ups 3. Instant replay markers 4. Heat maps for hit distribution 5. Social media integration for user comments). 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 ways to display the same stat) 2. Function modules unrelated to baseball scoring (e.g., irrelevant animations) 3. Fancy effects that affect performance (e.g., excessive particle animations that drain battery). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating data/view/controller layers), component reusability, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no error boundary or fallback UI implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional sports broadcasting standards?",
-      "description": "Evaluate whether the overall design follows professional sports visualization principles: 1) Clear team identification with logos and colors 2) Proper information hierarchy emphasizing current game situation 3) Professional typography (readable at small sizes, consistent labeling). Deduct 3 points for cluttered information display, 5 points for poor color contrast affecting readability, and 5 points for inconsistent visual styling across components. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the live streaming integration well-implemented?",
-      "description": "Judge whether the code properly integrates with streaming platforms: 1) Transparent or chroma-key background options 2) Configurable overlay positioning 3) Optimized rendering performance for streaming <5% CPU overhead. Deduct 5 points for each missing integration feature with Weibo or Douyin APIs, 3 points for streaming-unfriendly rendering methods, and 5 points if the overlay causes significant performance issues during test cases. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Daily Office Tasks",
-  "difficulty": "hard"
-}

package/library/utility_tools-daily_office_tasks/rich-text-editor-spelling-idiom-word-count.json

@@ -1,68 +0,0 @@
-{
-  "index": 1527,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable when possible. Create a rich text editor that implements features such as highlighting spelling mistakes, suggesting corrections for misused idioms (using a pre-loaded database of common errors), and word count statistics.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the rich text editor core functionality fully implemented?",
-      "description": "Review whether the code accurately implements a rich text editor with contentEditable or a custom text rendering system. Must include text formatting (bold, italic, underline), paragraph management, cursor positioning, and text selection handling. Score 0 if basic text editing is not functional, 5 if only simple formatting is implemented, and 10 if all core rich text features including undo/redo, copy/paste, and format preservation are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the spelling mistake detection and highlighting system properly implemented?",
-      "description": "Check whether the spelling checker uses an efficient algorithm (such as Levenshtein distance or BK-tree) with a comprehensive dictionary. Must include real-time highlighting with visual indicators (underlines/highlights) and performance optimization for large texts. Deduct 5 points if detection accuracy is below 90%, deduct 3 points if highlighting performance causes lag on texts over 1000 words. Full score requires sub-200ms response time.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the idiom correction suggestion system designed with intelligent matching?",
-      "description": "Evaluate whether the idiom database includes contextual matching algorithms and provides ranked suggestions based on semantic similarity. Must implement fuzzy matching for partial idioms and context-aware corrections. Deduct 5 points if suggestions are purely string-based without context consideration, deduct 3 points if the database contains fewer than 200 common idiom errors. Full score requires intelligent ranking and contextual relevance.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is comprehensive word count statistics and text analysis implemented?",
-      "description": "Check whether the system provides real-time statistics including word count, character count, paragraph count, reading time estimation, and readability metrics. Must handle various text formats and unicode characters correctly. Deduct 5 points if statistics are not updated in real-time, deduct 3 points if special characters or formatting affects accuracy. Give 10 points if advanced metrics like sentence complexity are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed input, large text files, clipboard data corruption, 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 writing experience (e.g., 1. Grammar checking with AI suggestions 2. Export to multiple formats (PDF, Word, Markdown) 3. Collaborative editing features 4. Voice-to-text integration 5. Writing analytics dashboard). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple spell-check engines running simultaneously) 2. Function modules unrelated to text editing (e.g., built-in games or media players) 3. Fancy effects that affect performance (e.g., excessive animations during typing). Deduct 3 points for each redundancy found, and directly deduct 10 points if core editing 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 core/spell checker/UI layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the editor design follows modern design principles: 1) Clean, distraction-free writing environment 2) Proper typography with readable fonts (minimum 14px, line height ≥1.5) 3) Intuitive toolbar design with clear iconography 4) Consistent color scheme for different text states (normal, highlighted, error). Deduct 3 points for each cluttered UI element, 5 points for poor contrast ratios, and 5 points for confusing navigation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the editor interactions conform to user expectations: 1) Typing response delay ≤ 50ms 2) Spell-check highlighting appears within 300ms 3) Smooth scrolling and cursor movement 4) Intuitive keyboard shortcuts 5) Responsive suggestion popups. Deduct 5 points for each laggy interaction, 3 points for jarring visual updates during typing, and 5 points for missing standard editor shortcuts (Ctrl+B, Ctrl+I, etc.). The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Daily Office Tasks",
-  "difficulty": "hard"
-}

package/library/utility_tools-daily_office_tasks/shopping-price-comparison-program.json

@@ -1,68 +0,0 @@
-{
-  "index": 1107,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Write me a small shopping price comparison program.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core price comparison functionality implemented?",
-      "description": "Check if the code implements the ability to compare prices of products across different sources/stores. It should include data structures to store product information (name, price, source) and algorithms to sort/filter by price. Score 0 if comparison logic is missing, 5 if basic comparison exists but lacks comprehensive filtering, and 10 if advanced sorting, filtering, and product matching functionality is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the program handle multiple data sources?",
-      "description": "Evaluate whether the program can retrieve product information from multiple sources (e.g., web scraping, APIs, local database, manual input). Deduct 5 points if only a single data source is supported, 3 points if multiple sources but no error handling for failed sources. The full score is 10 points if it handles multiple sources with proper fallback mechanisms.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the data collection/retrieval process well-designed?",
-      "description": "Review how product data is collected and stored. Check for web scraping capability, API integration, or user input mechanisms. Deduct 5 points if the data collection is hardcoded with no extensibility, and 3 points if there's no validation for collected data. Award 10 points for a comprehensive system with configurable data providers and proper caching.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the user interface intuitive and functional?",
-      "description": "Assess whether the program provides a clear interface (CLI, GUI, web) for users to search products, view comparisons, and sort results. Deduct 5 points for a difficult-to-navigate interface, 3 points if search/filter functionality is limited. Award 10 points for an intuitive interface with clear product displays, sorting options, and filter capabilities.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as network errors, malformed input data, unavailable sources, 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. Price history tracking and alerts 2. AI-powered deal recommendations 3. Coupon integration 4. Browser extension for real-time comparisons). 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 filtering mechanisms that do the same thing) 2. Function modules unrelated to price comparison (e.g., a built-in calculator when simple math would suffice) 3. Fancy effects that affect performance (e.g., excessive animations in a utility app). 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 collection/processing/display layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Daily Office Tasks",
-  "difficulty": "easy"
-}

package/library/utility_tools-daily_office_tasks/small-japanese-translation-program.json

@@ -1,68 +0,0 @@
-{
-  "index": 1359,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration when possible. Help me write a small Japanese translation program.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core translation functionality implemented correctly?",
-      "description": "Evaluate whether the code implements the essential Japanese-English translation capability through proper API integration or local dictionary lookup. Score 0 if no translation functionality exists, 5 if basic word translation is implemented, and 10 if the solution handles phrases, sentences, and different forms of Japanese characters (hiragana, katakana, kanji).",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the input processing for Japanese text properly implemented?",
-      "description": "Check whether the code correctly handles various Japanese character inputs (hiragana, katakana, kanji, romaji conversion) and implements proper text segmentation for accurate translation. Deduct 3 points if romaji-to-kana conversion is missing, 3 points if text normalization is absent, and 4 points if there's no handling for mixed character types. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a flexible user interface for text input and display?",
-      "description": "Assess whether the program provides a clean interface for entering Japanese text and viewing translations, including proper text direction support and appropriate fonts. Score 0 for command-line only, 5 for basic UI without proper Japanese text rendering, and 10 for a complete UI with proper Japanese font rendering and text direction support.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the program handle language-specific features?",
-      "description": "Evaluate support for Japanese-specific linguistic features such as particles, honorifics, context-dependent meanings, and furigana display. Deduct 2 points for each missing key feature. Check if the solution provides explanations for grammar points or cultural context when relevant. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid input, network interruption when using translation APIs, unsupported characters, 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. Audio pronunciation 2. Handwriting recognition for kanji 3. Character stroke order animations 4. Context-aware translations). 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 translation engines doing the same thing without clear benefit) 2. Function modules unrelated to translation (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 translation logic/UI/API layers), error handling, and documentation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the design follows modern standards: 1) Clear visual distinction between Japanese and English text 2) Proper font selection for both languages (proper rendering of Japanese characters) 3) Consistent spacing and alignment for bidirectional text. Deduct 3 points for each readability issue, 5 points for inappropriate font usage, and 5 points for poor layout that affects text legibility. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the translation experience is responsive and intuitive: 1) Translation response time ≤ 1 second 2) Smooth transitions between input and output 3) Clear visual feedback during processing. Deduct 5 points for each operation without feedback, 3 points for noticeable lag in translation responses, and 5 points for confusing interaction flow. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Daily Office Tasks",
-  "difficulty": "easy"
-}