npm - @getollie/cli - Versions diffs - 0.0.1 - Mend

@getollie/cli 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1798) hide show

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

@@ -0,0 +1,68 @@
+{
+  "index": 386,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure that the generated code is executable for demonstration. I am currently writing a Chrome browser extension.\n\nI want to implement the ability to control target webpage elements' clicking through my extension window.\n\nMy current browser extension page is as follows:\n```html\n<!DOCTYPE html>\n<html>\n<head>\n  <meta charset=\"utf-8\">\n  <title>Order Assistant</title>\n  <!-- Must strictly maintain loading order -->\n  <script src=\"js/jquery.min.js\"></script>\n  <script src=\"js/jquery.cookie.js\"></script>\n  <script src=\"js/miaoshou.js\"></script>\n  <script src=\"js/main.js\" type=\"module\"></script>\n\n  <link rel=\"stylesheet\" type=\"text/css\" href=\"css/main.css\">\n</head>\n<body>\n  <button id=\"getOrderBtn\" class=\"jq-btn\">Get Order</button>\n  <button id=\"refreshOrderBtn\" class=\"jq-btn\">Refresh Order</button>\n  <div id=\"resultContainer\"></div>\n</body>\n</html>\n```\n\nI'm using \"manifest_version\": 3,\nThe target website I want to operate on is erp.91miaoshou.com\nThe button to operate is the search button with attribute .J_queryFormSearch\nI want to use the query.main.js library.\nPlease help me output the complete extension code and the calling method.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Content Script properly implemented to interact with target webpage?",
+      "description": "Check if the code properly implements a content script that can access and interact with DOM elements on erp.91miaoshou.com. It should include proper event listeners, message passing mechanisms between content script and background/popup, and target the correct elements (.J_queryFormSearch). Score 0 if content script is missing, 5 if basic implementation exists but has limitations, 10 if fully implemented with error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Message Passing mechanism between extension components properly implemented?",
+      "description": "Evaluate whether the code implements Chrome extension message passing (chrome.tabs.sendMessage/chrome.runtime.sendMessage) correctly for communication between popup, background script, and content script. Check for proper message formatting, response handling, and error handling. Deduct 5 points if one-way communication only, 3 points if error handling is missing. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the manifest.json file correctly configured?",
+      "description": "Check if manifest.json follows Manifest V3 specification with proper permissions (host permissions for erp.91miaoshou.com), content scripts declaration with correct matches, background script configuration, and web_accessible_resources if needed. Deduct 3 points for each missing critical permission, 5 points for incorrect content script matching patterns, and 5 points for security issues like excessive permissions. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the integration with query.main.js library properly implemented?",
+      "description": "Verify whether query.main.js is correctly incorporated and utilized in the extension. Check if it's properly loaded, initialized, and used for DOM manipulation. Examine if the library's dependencies are handled correctly. Deduct 5 points if the library is included but not properly initialized, 3 points if there are conflicts with jQuery, 5 points if the library functionality is reimplemented instead of using the library. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as target element not found, website structure changes, network issues, permission denials, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Advanced element targeting with fallback selectors 2. Visual feedback for clicked elements 3. Automated action sequences). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to access the DOM) 2. Function modules unrelated to the clicking operation (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., complex animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI logic/DOM manipulation/message passing), error handling, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation of concerns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the extension UI meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the extension interaction smooth and responsive?",
+      "description": "Judge whether the interaction flows conform to user expectations: 1) Click feedback delay ≤ 100ms 2) Clear visual indication of operation success/failure 3) Logical workflow from popup to target website. Deduct 5 points for each operation without feedback, 3 points for delayed responses (> 300ms), and 5 points for confusing user flow. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "easy"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 1647,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure that the generated code is executable for demonstration. Develop a Chrome plugin with a feature that listens for the Alt+X shortcut key to open a search box, similar to Apple's Spotlight Search, using Vue 3 and Naive UI.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Chrome extension core structure properly implemented?",
+      "description": "Verify if the code includes all essential Chrome extension files (manifest.json, background.js, popup.html, etc.) with proper configuration. Check if the manifest.json correctly specifies permissions (commands for keyboard shortcuts, tabs, storage), and if version 3 manifest standards are followed. Score 0 if essential files are missing, 5 if basic structure exists but has configuration issues, 10 if fully implemented according to Chrome extension best practices.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Alt+X keyboard shortcut properly implemented?",
+      "description": "Evaluate whether the extension correctly registers and listens for the Alt+X keyboard shortcut using Chrome's commands API. Check if the shortcut works globally across tabs and is properly defined in manifest.json. Verify error handling when the shortcut might be unavailable. Score 0 if shortcut functionality is missing, 5 if implemented but not working reliably, 10 if fully functional with appropriate fallbacks.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the search box UI properly implemented with Vue 3 and Naive UI?",
+      "description": "Check if Vue 3's Composition API is used correctly and if Naive UI components are properly imported and configured. Verify if the search box appears centered on screen with proper focus, has appropriate styling (blur effect, rounded corners, etc.), and follows Spotlight's minimalist aesthetic. Deduct 5 points if Vue 3 features are underutilized, 3 points if Naive UI theming is inconsistent, and 5 points if the search box appearance differs significantly from Spotlight.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the search functionality comprehensive and effective?",
+      "description": "Assess whether the search function includes indexing of browser history, bookmarks, open tabs, and potentially web search. Check if results appear in real-time as the user types with proper debouncing (≤150ms), and if categorization of results is clear. Verify if the code implements fuzzy matching algorithms. Score 0 if search is basic text matching only, 5 if it searches multiple sources but lacks optimization, 10 if search is comprehensive with intelligent ranking algorithms.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as conflicting shortcuts, search indexing failures, API rate limits, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Custom search providers integration 2. Search history with analytics 3. AI-powered result ranking). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple search algorithms running simultaneously) 2. Function modules unrelated to search functionality (e.g., built-in games or utilities) 3. Fancy effects that affect performance (e.g., excessive animations or transitions). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/logic/data layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Search results appear within 200ms after typing 2) Transition animations controlled between 150-300ms 3) Clear keyboard navigation support (up/down arrows, Enter to select). Deduct 5 points for search lag exceeding 500ms, 3 points for janky animations during result rendering, and 5 points for lack of keyboard navigation. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 1781,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for demonstration. I need your help to write an HTML application that implements the following functions:\n\nRemind to clock in 5 minutes before work starts on each working day (excluding public holidays). Remind to clock out and sign in for overtime at 18:01. Remind to sign out from overtime at 20:31.\n\nThe screen must remain locked until the clock-in/out is completed. Each time someone clocks in or out, they will receive an encouraging message to provide emotional value.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the timed reminder functionality properly implemented?",
+      "description": "Evaluate whether the code correctly implements timed reminders that trigger at the specified times (5 minutes before work starts, 18:01 for clock-out/overtime sign-in, and 20:31 for overtime sign-out). Check if the application correctly excludes weekends and public holidays from the reminder schedule. Deduct 5 points if any of the reminder times are incorrectly implemented, and 5 points if the holiday exclusion logic is missing or flawed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the screen locking mechanism implemented effectively?",
+      "description": "Check if the application implements a screen locking mechanism that prevents access until clock-in/out is completed. Verify that the lock cannot be easily bypassed and persists until the required action is taken. Deduct 5 points if the lock can be bypassed, 3 points if the lock doesn't persist properly, and 2 points if the lock doesn't provide clear instructions on how to unlock. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are emotional value messages implemented with the clock-in/out system?",
+      "description": "Evaluate whether encouraging messages are displayed after each clock-in/out action. Check for variety in messaging (at least 5 different messages), contextual relevance (morning messages differ from evening ones), and positive emotional tone. Deduct 3 points if messages lack variety, 3 points if they're not context-aware, and 4 points if no messages appear at all. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the clock-in/out tracking system properly implemented?",
+      "description": "Assess whether the application correctly tracks and records clock-in/out events, including regular work hours and overtime. Check for proper data persistence (local storage at minimum), timestamp accuracy, and the ability to view history. Deduct 5 points if data isn't persisted between sessions, 3 points if timestamps are inaccurate, and 2 points if there's no history view. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser notifications being blocked, system time discrepancies, offline usage, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Statistical visualization of work patterns 2. Personalized motivation system based on user preferences 3. Integration with ambient notifications like subtle screen color changes). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple notification systems doing the same thing) 2. Function modules unrelated to attendance tracking (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the interface). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/business logic/data persistence layers), unit test coverage, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear organization or commenting. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Notification visibility and prominence when triggered 2) Transition animation duration controlled between 300-500ms when locking/unlocking screen 3) Clear visual feedback for successful clock-in/out actions. Deduct 5 points for each operation without feedback, 3 points for jarring transitions between states, and 5 points for notifications that are easy to miss. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "easy"
+}

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

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

package/library/utility_tools-automation/cs-grad-project-generator.json ADDED Viewed

@@ -0,0 +1,68 @@
+{
+  "index": 1294,
+  "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. I want to create a small program designed to help computer science graduates create their graduation projects. It will categorize graduation programs according to different types of functional systems, and then design an input template that allows users to input their system requirements. The program will then use the user's input along with predefined templates to generate code through AI, and integrate everything into a complete project.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the categorization system for graduation projects comprehensive and well-structured?",
+      "description": "Evaluate if the program provides a clear taxonomy of graduation project types (e.g., web applications, mobile apps, data analysis systems, IoT solutions, etc.). The categorization should be hierarchical with at least 3 levels of granularity and include at least 10 major categories with relevant subcategories. Deduct 3 points if major CS domains are missing, 5 points if categorization lacks proper hierarchy. Award full points only if the categorization is both comprehensive and logically structured.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the input templates for user requirements well-designed and domain-specific?",
+      "description": "Check if the templates are tailored to each project category with specific, relevant questions that guide users to provide comprehensive requirements. Templates should include mandatory fields (e.g., functional requirements, non-functional requirements, target users) and domain-specific fields (e.g., database schema fields for data-intensive applications, UI mockup options for frontend projects). Deduct 5 points if templates are too generic, 3 points if they lack validation for inputs. The full score requires dynamic template adaptation based on previous user inputs.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the AI code generation implementation effective and well-integrated?",
+      "description": "Review how the program interfaces with AI services for code generation. Check for proper API integration (with error handling and rate limiting), contextual prompt engineering that incorporates user requirements, and intelligent code assembly. Deduct 5 points if the AI integration lacks proper error handling, 5 points if it doesn't maintain context between requests, and 3 points if it doesn't provide progress feedback during generation. Full points require demonstrable code that can generate compilable project structures.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the program successfully integrate generated components into a complete project structure?",
+      "description": "Evaluate if the program properly assembles generated code modules into a cohesive project with correct dependency management, configuration files, and project structure. It should create proper directory structures, manage file relationships, resolve dependencies, and generate necessary build scripts or configuration files according to the project type. Deduct 5 points if integration creates conflicts, 3 points if build scripts are missing, and 5 points if dependencies aren't properly managed. Full points require a demonstration of a working project compilation/build process.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (invalid user inputs, API failures, insufficient permissions, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully handle edge cases and provide clear user guidance for recovery. Specifically check for input validation, error boundaries, logging mechanisms, and state recovery. Give 10 points for comprehensive error handling, 5 points for basic error handling, and 0 points if exceptions are unmanaged.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time visual preview of generated project structure 2. Intelligent suggestion system based on requirement analysis 3. Version control integration for project evolution tracking). 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 template engines doing the same work) 2. Function modules unrelated to project generation (e.g., a built-in game or entertainment feature) 3. Overly complex features that could be simplified. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separation of concerns between UI, requirement processing, code generation, and project assembly), 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-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/design-double-pinyin-input-method.json ADDED Viewed

@@ -0,0 +1,68 @@
+{
+  "index": 1228,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code can be executed and displayed when possible.\n\n1. Design a double-pinyin input method\n2. For consonants (initials), use the first letter of the pinyin, except for zero initial which uses 'o' or 'O'\n3. For vowels (finals), map them to single keys, but don't use i, I, u, U, v, or V as mapping keys\n4. Each two letters (consonant key + vowel mapping key) can form a pinyin syllable\n5. After inputting letters consecutively, the system should automatically recognize, split into pairs, and parse the pinyin\n6. When inputting an odd number of letters, the vowel candidate list should show options, such as \"an.a\" indicating that pressing 'a' would select the vowel \"an\" to form a pinyin syllable with the previous letter\n7. Update the Chinese character candidate list based on the pinyin parsed from the paired letters, with numbers to select candidate characters\n8. Present the input letters, vowel candidate prompts, and character candidate list in an interface similar to Sogou Input Method",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the double-pinyin mapping schema fully implemented?",
+      "description": "Check whether the code implements a complete double-pinyin mapping schema that correctly maps consonants to their first letter and vowels to single keys (excluding i, I, u, U, v, V). Verify that all Mandarin syllables are covered, including special cases like zero initial using 'o' or 'O'. Score 0 if the mapping is incomplete, 5 if basic mapping is implemented but with inconsistencies, and 10 if the mapping is complete and follows all specified rules.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the system correctly parse consecutive letter inputs into pinyin syllables?",
+      "description": "Evaluate if the code can automatically recognize and split consecutive letter inputs into pairs of consonant+vowel to form valid pinyin syllables. Test with various input sequences including edge cases (e.g., multiple syllables, syllables with different tone marks). Deduct 5 points if the parsing logic fails on complex inputs, and 3 points if it doesn't handle special cases. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the vowel candidate list correctly implemented for odd number of inputs?",
+      "description": "Check whether the system displays appropriate vowel candidates when an odd number of letters is input (e.g., 'an.a' indicating that pressing 'a' would select 'an'). Verify that the display format is clear and follows the format in the requirement. Deduct 5 points if the vowel candidate list is incomplete or inaccurate, and 3 points if the display format is confusing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the system update the Chinese character candidate list based on parsed pinyin?",
+      "description": "Evaluate if the code correctly updates the Chinese character candidate list based on the parsed pinyin and allows selecting candidates with numbers. Test with various pinyin combinations, including common and rare characters. Deduct 5 points if the candidate generation is incomplete or inaccurate, and 3 points if the number selection mechanism is not implemented properly. 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 combinations, edge cases like repeated consonants, or invalid pinyin sequences) 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. Fuzzy pinyin matching 2. User-customizable mapping schema 3. Learning from user habits to prioritize frequent characters). 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 pinyin parsing algorithms coexisting) 2. Function modules unrelated to input method (e.g., a built-in dictionary lookup) 3. Fancy effects that affect performance (e.g., excessive animations during character 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 mapping logic/UI/character database), unit test coverage, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between the core logic and the UI. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the input method interface follows modern design principles similar to Sogou Input Method: 1) Clean and unobtrusive input area 2) Clear distinction between input letters, vowel candidates, and character candidates 3) Professional typography with appropriate font sizes for different elements. Deduct 3 points for each cluttered UI element, 5 points for poor visual hierarchy, and 5 points for inconsistent styling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the typing experience smooth and responsive?",
+      "description": "Judge whether the input method provides a smooth typing experience: 1) Input latency ≤ 50ms 2) Fast candidate list updates 3) Intuitive selection mechanism with clear visual feedback. Deduct 5 points for noticeable input lag, 3 points for jerky candidate list updates, and 5 points for confusing selection mechanisms. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/distributed-computing-client-with-browser-execution.json ADDED Viewed

@@ -0,0 +1,68 @@
+{
+  "index": 557,
+  "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 whenever possible. Implement a distributed computing client that can receive computation tasks assigned by the server, execute calculations in the browser, and return the results. The system should support task pausing and resumption, display computation progress and resource usage. The system needs to be able to distribute workload among multiple clients and handle client disconnection scenarios.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the distributed computing client core functionality fully implemented?",
+      "description": "Review whether the code implements the core functionality to receive tasks from the server, process them, and return results. Check if WebWorkers are used for CPU-intensive tasks to prevent UI blocking. Score 0 if basic task processing is missing, 5 if only simple task execution is implemented, and 10 if it handles complex computation scenarios with proper threading model.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the task pausing and resumption mechanism properly implemented?",
+      "description": "Evaluate whether the code includes robust mechanisms for pausing ongoing computations and resuming them from the saved state. Check if computation state serialization is implemented correctly. Deduct 5 points if only simple task termination (not true pausing) is implemented, and 3 points if the resumption doesn't properly restore previous state. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the progress and resource usage monitoring system comprehensive?",
+      "description": "Check if the implementation includes real-time progress tracking (percentage completion, estimated time remaining) and system resource monitoring (CPU usage, memory consumption, network bandwidth). Deduct 3 points if progress tracking is inaccurate, 4 points if resource usage statistics are missing, and 5 points if the metrics aren't visualized effectively. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the client disconnection handling mechanism robust?",
+      "description": "Assess whether the code includes a comprehensive strategy for handling client disconnections (such as local task caching, reconnection attempts, progress persistence). Check if the system can redistribute incomplete tasks to other clients. Deduct 5 points if work is completely lost upon disconnection, and 3 points if reconnection doesn't restore previous context. 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 computation errors, browser crashes, invalid task data, network instability) 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. Smart prioritization of tasks based on client capabilities 2. P2P task sharing between clients 3. Dynamic throttling based on device thermal conditions). 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 task scheduling algorithms running in parallel) 2. Function modules unrelated to distributed computing (e.g., unrelated analytics) 3. Fancy effects that affect performance (e.g., excessive animations that consume CPU). 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 computation logic/UI/network 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 data visualization for computation metrics (appropriate charts and graphs). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for illegible metrics displays. 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) Real-time UI updates don't interfere with computation 2) Task status changes have clear visual transitions 3) Resource usage metrics update smoothly without flickering. Deduct 5 points for each operation without feedback, 3 points for UI freezes during heavy computation, and 5 points for confusing state transitions between computation phases. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/electron-realtime-speech-to-text-translation.json ADDED Viewed

@@ -0,0 +1,68 @@
+{
+  "index": 1644,
+  "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. I'm asking this question because I want to transmit users' real-time voice recordings to an SDK that will automatically convert speech to text. For example, a user could open an English video and simultaneously open my application, so while watching English videos, they can get real-time text conversion. Then, I'll call a text translation API to convert the text into Chinese. Please give me detailed instructions on how to create this project using Electron and implement a real-time voice recording demo.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the voice recording functionality properly implemented?",
+      "description": "Check whether the code correctly implements access to the microphone using Electron's native APIs or Web APIs (getUserMedia), and whether it properly handles permission requests and denials. Evaluate whether the recording process includes proper audio sampling rate (minimum 16kHz for speech recognition), bit depth (minimum 16-bit), and format configuration. Score 0 if recording functionality is missing, 5 if basic recording is implemented but with configuration issues, and 10 if properly implemented with customizable audio parameters and resource cleanup.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is real-time audio streaming to the speech recognition SDK implemented correctly?",
+      "description": "Evaluate whether the code establishes proper streaming connections to a speech recognition SDK (like Google Speech-to-Text, Amazon Transcribe, or Mozilla DeepSpeech). Check if the audio data is properly chunked and streamed in real-time rather than processed after complete recording. Ensure the implementation handles rate limiting, reconnection, and authentication with the SDK. Score 0 if no streaming implementation exists, 5 if basic implementation but without proper error handling or optimization, and 10 if fully implemented with buffering strategies and connection management.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the speech-to-text conversion properly integrated and displayed?",
+      "description": "Review whether the transcribed text is displayed in real-time with appropriate UI updates. Check if interim results are handled differently from final results, and if the text display includes timestamps or speaker identification if available. Verify if the implementation addresses common STT challenges like handling speech disfluencies and punctuation. Deduct 5 points if there's significant display lag (>500ms), and 3 points if the text formatting is poor or unreadable. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the text translation API integration implemented effectively?",
+      "description": "Evaluate the integration with a translation API (like Google Translate, DeepL, or Microsoft Translator). Check if the code handles API rate limits, caching of frequent translations, and batching of text segments for efficiency. Assess whether the translation happens in near real-time and if the implementation includes fallback mechanisms when API calls fail. Deduct 5 points if translations have significant delays (>1s), and 3 points if no error handling exists for API failures. 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 microphone disconnection, API rate limiting, network interruption, 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. Noise cancellation for better recognition 2. Multi-language support with automatic language detection 3. Exportable transcription history with timestamps 4. Voice activity detection to reduce API costs). Add 2.5 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple audio processing libraries doing the same job) 2. Function modules unrelated to voice recording and translation (e.g., unnecessary media playback features) 3. Fancy effects that affect performance (e.g., complex visualizations that consume CPU). 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 recording/recognition/translation/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 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 application performance optimized?",
+      "description": "Judge whether the application is optimized for performance: 1) CPU usage remains under 15% during recording 2) Memory leaks are prevented with proper resource disposal 3) Electron's IPC communication is optimized to avoid blocking the main thread. Deduct 3 points if CPU spikes above 30% during normal operation, 5 points if memory usage grows consistently during usage, and 5 points if the UI freezes during intensive operations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}