@getollie/cli 0.0.4 → 0.2.0

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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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"
-}

package/library/utility_tools-automation/ethernet-packet-capture-vue2-electron-app.json

@@ -1,68 +0,0 @@
-{
-  "index": 1618,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration. Create a local Ethernet packet capture software using Vue 2.0 and package it into a desktop application with Electron.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the packet capture functionality fully implemented?",
-      "description": "Review whether the code correctly implements core packet capture functionality using appropriate libraries (like libpcap/npcap/node-pcap) with Vue 2.0. Check if it captures packet headers and payloads, performs protocol analysis, and allows filtering of packets. Score 0 if core capture logic is absent, 5 if basic capture works but lacks protocol analysis, and 10 if it fully implements capture with comprehensive protocol decoding (TCP/IP, HTTP, DNS, etc.).",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Electron integration complete for system-level operations?",
-      "description": "Evaluate if the codebase properly implements Electron's IPC mechanism for communication between renderer and main processes, particularly for accessing system network interfaces which require elevated privileges. Check for proper permissions handling, native module bindings, and system tray integration. Deduct 5 points if raw socket access isn't properly implemented, 3 points if security permissions aren't handled correctly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the Vue 2.0 architecture implemented according to best practices?",
-      "description": "Check if the Vue architecture follows component-based design with proper state management (Vuex), routing (vue-router), and lifecycle hooks. Evaluate component reusability and proper separation of concerns. Deduct 5 points if global state management is missing or incorrectly implemented, 3 points if component design is monolithic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is real-time packet visualization and analysis provided?",
-      "description": "Assess whether the application provides real-time packet visualization (charts, graphs, traffic flow diagrams) with appropriate refresh rates. Check if statistical analysis tools are available (bandwidth usage, protocol distribution, connection tracking). Deduct 5 points if visualization updates are delayed (>1s latency), and 3 points if analysis features are minimal. Full score requires both comprehensive visualization and analysis capabilities.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as permission denials, network adapter failures, high traffic volumes, 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. Automated security threat detection 2. Packet replay functionality 3. Network topology visualization 4. Protocol-specific decoders for application layer protocols). 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 packet filtering systems) 2. Function modules unrelated to packet capture (e.g., built-in media player) 3. Fancy effects that affect capture performance (e.g., excessive animations during packet capture). 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 capture logic/UI/analysis modules), 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 Electron packaging process is not automated or optimized. 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 packet display layouts. 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 during high packet capture rates. Deduct 5 points for each operation without feedback, 3 points for UI freezes during high traffic capture, and 5 points for hard-to-find filtering or analysis functions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "hard"
-}

package/library/utility_tools-automation/excel-group-assignment-tool.json

@@ -1,68 +0,0 @@
-{
-  "index": 1734,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Write an HTML code that can randomly assign people from an uploaded Excel file into groups, allowing selection of the number of people per group, while balancing gender and department distribution. The groups should be displayed on the page after completion, with a button to export the results to Excel. The Excel workbook contains a sheet with \"Name,\" \"Gender,\" and \"Department\" data.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Excel file upload and parsing functionality properly implemented?",
-      "description": "Check if the code uses reliable libraries (like SheetJS/xlsx) to handle Excel file parsing. Verify that file validation is implemented (file type check, size limit). Verify error handling for malformed Excel files. Score 0 if file upload is missing, 5 if basic upload works but lacks validation, and 10 if robust upload with proper error handling is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the group assignment algorithm properly implemented with balanced distribution?",
-      "description": "Evaluate if the algorithm effectively balances gender and department distribution across groups. Check if it handles edge cases (uneven distribution possibilities, empty cells). The algorithm should use statistical methods to ensure fairness. Deduct 5 points if only simple random assignment is implemented, 3 points if either gender or department balancing is missing, and give 10 points if sophisticated balancing with optimization logic is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the group size selection interface properly implemented?",
-      "description": "Check if users can select the number of people per group through an intuitive interface. Verify validation for input values (minimum/maximum constraints based on total participants). The interface should provide real-time feedback on how many groups will be created. Deduct 3 points if validation is missing, 5 points if there's no feedback on resulting group count, and give 10 points for a complete implementation with validation and feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the group result display and Excel export functionality properly implemented?",
-      "description": "Verify that grouped results are clearly displayed on the page with visual separation between groups. Check if the export to Excel functionality works correctly, maintaining the grouping structure in the exported file. Deduct 5 points if export doesn't maintain proper formatting, 3 points if visual display is confusing, and give 10 points for clear display with proper Excel export 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, unexpected data formats, empty fields, 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. Visualization of gender/department distribution per group 2. Drag-and-drop manual adjustments after auto-grouping 3. Group naming or color-coding options). 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 parsing methods) 2. Function modules unrelated to group assignment (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., complex animations that slow down the page). 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 processing/UI/export functionality), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation of concerns. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast processing, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "easy"
-}

package/library/utility_tools-automation/export-multiple-html-to-pdf-with-jspdf-react-tss.json

@@ -1,68 +0,0 @@
-{
-  "index": 849,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable. Implement a solution in React+TSS to export multiple HTML codes to PDF, setting an HTML template for the PDF while preserving CSS styles. The method should allow HTML with different parameters but the same framework to use the same export method. Do not use canvas drawing. Use jspdf - please provide a demo.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the PDF export functionality correctly implemented with jsPDF?",
-      "description": "Evaluate whether the solution correctly uses jsPDF library for HTML-to-PDF conversion without relying on canvas drawing. Check if the implementation includes proper initialization of jsPDF, handles page breaks appropriately, and correctly renders HTML content to PDF. Score 0 if jsPDF is not implemented, 5 if basic implementation exists but with limitations, and 10 if full HTML-to-PDF conversion works smoothly.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is CSS style preservation properly handled in the PDF export?",
-      "description": "Verify that the solution correctly preserves CSS styles when exporting HTML to PDF. Check if it handles complex CSS properties (flexbox, grid, media queries, etc.), custom fonts, and responsive designs. Deduct 3 points if basic styles are preserved but complex layouts break, 5 points if fonts or specific CSS properties aren't supported, and 10 points if no CSS preservation is implemented. Full score of 10 requires demonstration of preserving various CSS properties.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the HTML templating system flexible and reusable?",
-      "description": "Assess whether the solution implements a flexible HTML template system that can be used with different parameters. Check if the template system allows for dynamic content insertion, conditional rendering, and maintains the same structure across different data inputs. Deduct 3 points if templates are hardcoded, 5 points if templates have limited customization capability, and 8 points if templates cannot handle different data structures. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the solution provide a unified export method for different HTML content?",
-      "description": "Examine if the implementation offers a single, unified export method that works effectively with different HTML content but the same framework. Check for parameterization, abstraction level, and reusability of the export function. Deduct 3 points if separate export methods are needed for different HTML structures, 5 points if significant code modification is needed between exports, and 8 points if the method doesn't handle edge cases like large content or special characters. Full score requires a robust, unified export approach.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed HTML, excessive content length, special characters, image loading failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Preview functionality before export 2. Progress indicator during PDF generation 3. Batch export capability 4. Custom header/footer options). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple PDF generation methods coexisting) 2. Function modules unrelated to PDF export (e.g., unnecessary image processing) 3. Fancy effects that affect performance (e.g., excessive animations during export). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating PDF generation logic/template rendering/styling), TypeScript type safety, and React best practices. Deduct 5 points if global state pollution is found or TypeScript types are poorly implemented; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if React hooks are improperly used causing performance issues. 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) Export operation feedback ≤ 500ms 2) Loading indicators for lengthy operations 3) Clear visual guidance for export process. Deduct 5 points for each operation without feedback, 3 points for unresponsive UI during PDF generation, and 5 points for hard-to-find export function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "easy"
-}

package/library/utility_tools-automation/food-delivery-robot-mini-program-joystick-controls.json

@@ -1,68 +0,0 @@
-{
-  "index": 1268,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable if possible. Context: Food delivery robot project architecture: Frontend using uniapp vue3 js, API: Django, database: Django's built-in SQLite, MQTT service, ROS1. Requirements: Phone remote control sends MQTT messages, MQTT to JS, JS sends ROSJS to the robot's ROS1. Functionality needed: A mini-program compatible with both tablets and phones featuring smooth joystick controls for the robot vehicle.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the joystick control interface fully implemented?",
-      "description": "Review whether the code accurately implements a touchscreen joystick with HTML5/JavaScript, including touch event handling, movement range limitations, auto-centering, and haptic feedback. Score 0 if the core interaction is missing, 5 if basic movement is implemented but lacks responsive design, and 10 if the joystick works flawlessly across different screen sizes with proper touch and drag events.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the MQTT communication layer properly implemented?",
-      "description": "Check if the code includes MQTT client implementation with proper connection handling, topic subscription/publishing, QoS settings, and reconnection mechanisms. Verify that MQTT messages are properly formatted for robot control commands (velocity, direction, etc.). Deduct 5 points if there's no reconnection handling, 3 points if there's no connection status indication, and 3 points if message encoding/serialization is inefficient. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the ROSJS bridge implementation complete?",
-      "description": "Evaluate whether the code properly implements roslibjs to communicate with ROS1, including WebSocket connection setup, topic publishing/subscription handling, service calls, and action client implementations. Check for proper error handling when ROS connection fails. Deduct 5 points if the implementation lacks connection state management, 3 points if it doesn't handle message type conversions properly, and 3 points if it doesn't include fallback mechanisms. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the Django API and database integration effectively designed?",
-      "description": "Assess whether the Django backend properly integrates with the frontend, including RESTful API endpoints for robot status/control, authentication mechanisms, and database models for storing robot states, user preferences, and operational logs. Check if the API includes proper validation, rate limiting, and error responses. Deduct 5 points if there's no authentication, 3 points if database models are poorly designed, and 3 points if the API lacks comprehensive documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruption, MQTT broker unavailability, ROS disconnection, device orientation changes, 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. Visual robot path preview 2. Battery level indicators with predictive alerts 3. Obstacle detection visualization 4. Motion gesture controls as joystick alternatives). 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 control mechanisms (e.g., multiple joystick libraries combined) 2. Function modules unrelated to robot control (e.g., unnecessary social sharing features) 3. Fancy effects that affect performance (e.g., excessive animations that impact responsiveness). 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 control logic/UI/communication layers), unit test coverage, and build process automation. Examine uniapp component organization, Vue3 composition API usage, and code splitting strategies. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times) 4) Adaptive layouts for both tablet and phone form factors. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for failing to properly adapt between tablet and phone layouts. 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) Joystick control latency ≤ 50ms 2) Robot response visualization updates at ≥30fps 3) Clear visual feedback for connection status changes. Measure actual touch-to-movement latency in the control system. Deduct 5 points for each operation without feedback, 3 points for joystick stuttering during fast movements, and 5 points for control commands that execute with >200ms delay. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "hard"
-}