@getollie/cli 0.0.1

package/library/utility_tools-batch_processing/speech-to-text-tool-with-features.json

@@ -0,0 +1,68 @@
+{
+  "index": 479,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration. Develop a speech-to-text tool that allows users to upload audio files (mp3, wav formats) or record speech in real-time using a microphone. The tool should convert speech content into text and display the recognition results on the interface in real-time. Users should be able to pause, continue input, and edit the recognized text. The interface should also provide language selection (supporting at least English and Chinese), speech rate adjustment functionality, and text export capabilities (supporting txt and doc formats). You can use the browser's built-in speech recognition API or integrate third-party APIs.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the audio input functionality fully implemented?",
+      "description": "Evaluate whether the implementation properly handles both file uploading (.mp3, .wav formats) and real-time microphone recording. Check for proper file validation, format detection, and error handling for unsupported formats. Verify that the microphone access requests appropriate browser permissions and provides fallback options. Score 0 if neither input method works, 5 if only one method is implemented or both have significant issues, and 10 if both methods are fully functional with proper error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the speech recognition mechanism work effectively?",
+      "description": "Assess the implementation of speech recognition using either the browser's Web Speech API or integration with third-party services (like Google Speech-to-Text, Azure Speech, etc.). Check for proper initialization, event handling, error recovery, and continuous recognition capability. Verify language detection accuracy and appropriate handling of recognition confidence levels. Deduct 5 points if recognition doesn't work reliably, 3 points if language support is limited to fewer than two languages, and 2 points if there's no visible feedback during recognition. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the real-time transcription and editing features implemented?",
+      "description": "Evaluate whether the tool displays recognition results in real-time, provides pause/resume functionality for the speech recognition process, and allows for text editing of the recognized content. Check if the interim results are displayed differently from final results, if there's a clear visual indication of the recognition status, and if text editing preserves formatting and cursor position. Deduct 5 points if real-time display is missing, 3 points if pause/resume functionality doesn't work properly, and 3 points if text editing capabilities are limited. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is multilingual support with speech rate adjustment implemented?",
+      "description": "Check if the tool supports at least English and Chinese language selection with proper UI controls. Verify that changing languages actually affects the recognition results. Additionally, evaluate the implementation of speech rate adjustment (slow, normal, fast) and its effect on recognition accuracy. Deduct 5 points if language switching doesn't work properly, 3 points if fewer than two languages are supported, and 3 points if speech rate adjustment is missing or non-functional. 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 access denial, audio file corruption, network interruption, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Speaker diarization (distinguishing between different speakers) 2. Automatic punctuation and formatting 3. Real-time translation capabilities alongside transcription 4. Voice activity detection with visual feedback). 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 audio processing pipelines) 2. Function modules unrelated to speech-to-text (e.g., unnecessary media players) 3. Fancy effects that affect performance (e.g., excessive animations that delay transcription display). 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 audio processing/recognition/display layers), error handling, and performance optimization. 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 resource management is poor (e.g., memory leaks, unclosed audio streams). 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) Clear visual feedback when speech is being recorded or processed 2) Smooth transitions between recording states and recognition results 3) Intuitive controls for pausing, resuming, and exporting text. Deduct 5 points for each operation without feedback, 3 points for laggy text updates during recognition, and 5 points for hard-to-find key function buttons like language selection or export options. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Batch Processing",
+  "difficulty": "easy"
+}

package/library/utility_tools-calculation_tools/bazi-marriage-compatibility-calculator-mini-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 1670,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for display. Please provide a lightweight solution for a marriage compatibility calculator mini-program based on the Chinese BaZi (Eight Characters) system for matchmaking agencies or fortune-telling services. Include core functionalities, technical implementation paths, and commercialization suggestions, along with open-source program code that can be quickly implemented even with zero coding background.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the BaZi calculation engine correctly implemented?",
+      "description": "Evaluate whether the code accurately implements the Chinese lunar calendar conversion and BaZi (Eight Characters) derivation, including the calculation of year, month, day, and hour pillars. Check if the code handles special cases like leap months and date boundary conditions. Score 0 if the core calculation is incorrect, 5 if basic calculations are implemented but with minor errors, and 10 if all calculations including Stems and Branches are accurately implemented with proper documentation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the compatibility matching algorithm comprehensively developed?",
+      "description": "Assess whether the code includes a complete compatibility analysis system that considers the Five Elements relationships, Ten Gods theory, and clash/harmony combinations between the couples' BaZi charts. Check if the algorithm calculates both major compatibility indicators (e.g., day master relationships) and minor influences. Deduct 5 points if only basic Yin-Yang balance is considered, and 3 points if the detailed scoring system lacks weighted factors. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the user input system user-friendly and error-tolerant?",
+      "description": "Review whether the birth date and time input system supports multiple formats (Gregorian/Lunar calendar), handles timezone differences, and provides clear guidance for accurate information collection. Check if validation is implemented to prevent impossible dates or nonsensical inputs. Deduct 5 points if validation is missing, 3 points if the interface doesn't support both calendar systems, and 2 points if time selection is imprecise or confusing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the compatibility result presentation clear and customizable?",
+      "description": "Evaluate whether the results display includes visual elements (charts, symbols, or color-coding), clear textual explanation of compatibility scores, and actionable insights. Check if the system allows for different levels of detail based on user preferences or business needs. Deduct 5 points if visual representation is missing, 3 points if explanations are vague or generic, and 2 points if there's no customization option. 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 dates, partial information, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Visualization of five elements balance 2. Compatibility trends across time 3. Integration with social sharing). 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 calendar conversion methods coexisting) 2. Function modules unrelated to BaZi compatibility (e.g., extensive horoscope readings) 3. Fancy effects that affect performance (e.g., unnecessary animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating calculation logic/view/data layers), maintainability, and simplified deployment process. 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 deployment process requires advanced technical knowledge. 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 (traditional Chinese colors with appropriate contrast) 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 commercial viability addressed comprehensively?",
+      "description": "Judge whether the solution includes practical monetization strategies, scalability considerations, and market positioning for matchmaking agencies or fortune-telling services. Check if there are tiered service options, data privacy protections, and customization possibilities for business clients. Deduct 5 points if monetization strategy is missing, 3 points if scalability isn't addressed, and 2 points if there's no consideration for white-labeling or business customization. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "hard"
+}

package/library/utility_tools-calculation_tools/bmi-body-fat-calculator.json

@@ -0,0 +1,68 @@
+{
+  "index": 1512,
+  "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. Create a simple BMI body fat calculator using DevEco. Below are some code snippets that you can try to complete, or you can directly generate the code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the BMI calculation formula correctly implemented?",
+      "description": "Check whether the BMI calculation formula (weight(kg)/height(m)²) is accurately implemented with proper unit conversion (if user inputs in different units). Verify input validation for height and weight (non-negative values, reasonable range checks). Score 0 if calculation is incorrect, 5 if basic calculation is implemented but lacks input validation, and 10 if perfect with validation and unit options.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the body fat percentage calculation included?",
+      "description": "Evaluate if the calculator includes body fat percentage calculations using established formulas (e.g., Navy method, Jackson-Pollock). Check if it requests required inputs like gender, age, and appropriate body measurements. Score 0 if absent, 5 if implemented but using only basic formulas without considering age/gender variables, 10 if comprehensive with multiple calculation methods.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the DevEco framework properly utilized?",
+      "description": "Check if the code correctly utilizes DevEco Studio and HarmonyOS/OpenHarmony frameworks. Verify proper component structure, lifecycle management, and appropriate use of ArkUI/eTS features. Deduct 5 points if not using DevEco-specific components when appropriate, 3 points if not following recommended architecture patterns. Full score requires proper DevEco project structure and appropriate use of platform-specific features.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the calculation results interpreted with proper health guidance?",
+      "description": "Review whether the application provides interpretation of BMI/body fat results according to standard health categories (Underweight, Normal, Overweight, Obese) with appropriate health recommendations. Check if visual indicators (color coding, charts) are used to represent different health ranges. Score 0 if no guidance, 5 if basic categories without recommendations, 10 if comprehensive with visualizations and personalized guidance.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as empty inputs, non-numeric inputs, extreme values, 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. Progress tracking over time 2. Visual body shape representation based on metrics 3. Dietary/exercise recommendations based on results). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar calculations 2. Function modules unrelated to health metrics (e.g., unnecessary social sharing features) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating calculation logic/view/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) 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-Calculation Tools",
+  "difficulty": "easy"
+}

package/library/utility_tools-calculation_tools/create-a-timer-no-programming-experience.json

@@ -0,0 +1,68 @@
+{
+  "index": 1728,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code when possible. As someone who has never learned computer programming languages, what should I do to create this timer?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the timer core functionality fully implemented?",
+      "description": "Review whether the code accurately implements basic timer functions including start/pause/reset/stop operations through HTML/JavaScript, and whether it includes time display formatting (hours:minutes:seconds) and countdown/countup modes. Score 0 if core timing logic is not implemented, 5 if only basic start/stop is implemented, and 10 if all essential timer features are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the beginner-friendly code structure and documentation provided?",
+      "description": "Check whether the implementation includes comprehensive inline comments explaining each code block, step-by-step tutorial comments for programming beginners, and clear variable naming conventions. The code should be educational with explanations of basic programming concepts used. Deduct 5 points if comments are insufficient for beginners, and 3 points if variable names are not self-explanatory. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the learning progression structure well-designed for non-programmers?",
+      "description": "Evaluate whether the solution provides a clear learning path starting from basic HTML structure, then CSS styling, and finally JavaScript functionality. Should include explanations of why each technology is needed and how they work together. Deduct 5 points if the progression jumps complexity levels too quickly. Check whether prerequisite knowledge is explained before introducing new concepts. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are practical customization options and extensions provided?",
+      "description": "Check whether the code includes easy-to-modify features that beginners can experiment with, such as changing colors, sounds, timer intervals, or adding simple notifications. Should provide clear instructions on how to customize without breaking functionality. Deduct 5 points if no customization guidance is provided, and 3 points if modifications require advanced programming knowledge. Give 10 points if fully implemented with beginner-friendly customization options.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common user errors (such as invalid input, rapid clicking, browser refresh) and provide friendly error messages that beginners can understand. Code should include input validation and graceful error handling with clear explanations of what went wrong and how to fix it. Give 10 points for strong robustness, 5 points if average, and 0 points if no error handling exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that enhance learning?",
+      "description": "Check whether the code includes educational enhancements such as: 1. Interactive code playground with live preview 2. Step-by-step building process with intermediate results 3. Visual debugging aids or console logging explanations 4. Comparison with alternative implementation approaches. Add 3 points for each practical learning feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check for three types of redundancy: 1. Overly complex features that confuse beginners (e.g., advanced JavaScript frameworks when vanilla JS suffices) 2. Unrelated functionality that distracts from timer learning (e.g., complex animations or unrelated widgets) 3. Multiple ways to accomplish the same task without educational purpose. Deduct 3 points for each redundancy found, and directly deduct 10 points if core learning objectives are obscured by unnecessary complexity.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have educational engineering quality?",
+      "description": "Review whether the code follows beginner-friendly organization principles: clear file structure, logical code organization, and consistent coding style. Check for appropriate use of modern web standards while keeping complexity manageable for beginners. Deduct 5 points if code organization is confusing for learners; deduct 5 points if outdated or non-standard practices are used without explanation; deduct 5 points if the learning curve is too steep. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet beginner-friendly visual standards?",
+      "description": "Evaluate whether the visual design is clean, approachable, and educational: 1) Simple, clear color scheme that doesn't overwhelm beginners 2) Adequate button sizes and spacing for easy interaction 3) Clear visual hierarchy with obvious timer display and controls 4) Professional but not intimidating appearance. Deduct 3 points for each confusing visual element, 5 points for overwhelming or unprofessional design, and 5 points for poor readability or unclear interface elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the interaction design intuitive and beginner-accessible?",
+      "description": "Judge whether the interface behavior is predictable and learner-friendly: 1) Immediate visual feedback for all user actions 2) Clear button states and hover effects 3) Intuitive control placement and labeling 4) Smooth transitions that don't distract from functionality. Deduct 5 points for each non-obvious interaction, 3 points for delayed or missing feedback, and 5 points for confusing navigation or control logic. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "easy"
+}

package/library/utility_tools-calculation_tools/create-calculator-vs-form.json

@@ -0,0 +1,68 @@
+{
+  "index": 388,
+  "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. Create a calculator using VS Form.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic calculator functionality fully implemented?",
+      "description": "Verify if the calculator implements all basic operations (addition, subtraction, multiplication, division) correctly. Check if the calculation logic handles operator precedence properly. Score 0 if operations are missing, 5 if basic operations work but have precedence issues, and 10 if all operations work correctly with proper precedence handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are advanced calculator features implemented?",
+      "description": "Evaluate whether the calculator includes advanced features like parentheses support, memory functions (MC, MR, MS, M+, M-), percentage calculations, square/square root, and backspace functionality. Award 2 points for each well-implemented feature group, up to a maximum of 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is proper Windows Forms UI design implemented?",
+      "description": "Check if the calculator uses appropriate Windows Forms controls (Buttons, TextBox/Label for display). Verify if the layout uses proper container controls (TableLayoutPanel, FlowLayoutPanel) for organized button arrangement. Deduct 5 points if controls are inappropriately used, 3 points if the layout is disorganized. Give 10 points for professional-looking UI with proper control usage.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the input handling comprehensive?",
+      "description": "Assess if the code handles both button clicks and keyboard input. Check if it properly manages decimal point input, prevents multiple decimal points, handles display overflow, and manages input validation. Deduct 3 points for each missing input handling aspect. Award 10 points if all input scenarios are properly handled.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common edge cases (division by zero, overflow/underflow, invalid operations) and provides friendly error messages. Check if exceptions are properly caught and handled. Code with strong robustness should effectively handle these cases, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Look for surprise features that enhance the experience (e.g., 1. Scientific calculation mode 2. History of calculations 3. Customizable themes/appearance 4. Converter functionality). 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 calculation engines) 2. Function modules unrelated to calculator functionality 3. Fancy effects that affect performance unnecessarily. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating calculation logic from UI), appropriate use of event handlers, proper variable naming conventions, and code comments. Deduct 3 points if global variables are overused; deduct 3 points if the code lacks comments; deduct 4 points if the code structure is monolithic with no separation of concerns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional standards?",
+      "description": "Evaluate whether the calculator follows modern design principles: 1) Consistent button sizing and spacing 2) Clear visual hierarchy between display and buttons 3) Professional color scheme appropriate for a calculator 4) Proper form sizing and resizing behavior. Deduct 2.5 points for each design issue found. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the user interaction smooth and intuitive?",
+      "description": "Judge whether the interaction follows standard calculator behavior: 1) Clear visual feedback when buttons are pressed 2) Proper focus management 3) Intuitive handling of operation sequences 4) Clear display formatting of numbers with thousands separators or scientific notation when needed. Deduct 2.5 points for each interaction issue found. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "medium"
+}

package/library/utility_tools-calculation_tools/currency-exchange-rate-calculator-with-history.json

@@ -0,0 +1,68 @@
+{
+  "index": 602,
+  "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. Design a currency exchange rate calculator that allows users to input an amount and currency, then displays real-time conversion results based on their selected target currency, and supports querying historical exchange rate records by date.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core currency conversion functionality fully implemented?",
+      "description": "Review whether the code implements accurate currency conversion with real-time exchange rates fetching. Check if the application properly handles currency input, selection, and result display with appropriate decimal precision. Score 0 if core conversion is missing, 5 if basic conversion exists without real-time rates, and 10 if fully implemented with accurate exchange rate API integration.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the historical exchange rate querying feature implemented?",
+      "description": "Evaluate whether users can select specific dates and retrieve historical exchange rates. Check if the application includes date validation, proper handling of non-trading days, and visualization of historical data (tables or charts). Deduct 5 points if only current-day lookups are possible, and 3 points if date selection exists but validation is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the exchange rate data source properly implemented and managed?",
+      "description": "Check whether the application connects to a reliable exchange rate API, implements proper error handling for API failures, and includes a fallback mechanism (like cached rates). Verify if rate updates occur at appropriate intervals without excessive API calls. Deduct 5 points for missing API error handling, 3 points for no caching strategy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are currency selection and input validation properly implemented?",
+      "description": "Review whether the application provides a comprehensive list of currencies with appropriate symbols/codes, implements input validation for amounts (preventing negative values, non-numeric inputs), and handles currency selection changes correctly. Deduct 3 points for missing validation, 4 points for incomplete currency options, and 3 points for improper handling of selection changes. 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 API failures, network interruption, invalid user inputs, 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. Currency trend visualization 2. Favorite currency pairs saving 3. Rate alerts/notifications when thresholds are met). 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 API calls for the same data) 2. Function modules unrelated to currency exchange (e.g., unnecessary weather widgets) 3. Fancy effects that affect performance (e.g., excessive animations during simple conversions). 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 API services/UI components/state management), 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) Currency selection and conversion calculation response ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual feedback when rates update or calculations complete. Deduct 5 points for each operation without feedback, 3 points for laggy responses during currency switching, and 5 points for confusing interaction flows. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "easy"
+}

package/library/utility_tools-calculation_tools/e-commerce-profit-calculation-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 1570,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration purposes. Help me create an e-commerce profit calculation tool.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core profit calculation functionality fully implemented?",
+      "description": "Review whether the code accurately implements the fundamental profit calculation formulas (Revenue - COGS - Expenses), with proper handling of different units (currency, percentages). Score 0 if the core calculation is not implemented, 5 if basic calculations are present but missing important metrics like margins or ROI, and 10 if all essential e-commerce metrics (gross/net profit, margins, ROI, break-even analysis) are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the tool provide comprehensive input handling for e-commerce variables?",
+      "description": "Evaluate whether the code handles all necessary e-commerce variables: product costs, selling price, shipping fees, payment processing fees, marketing costs, returns/refunds rate, taxes, and operational costs. Deduct 2 points for each critical missing variable. Check if validation is in place to prevent nonsensical inputs (negative prices, percentages over 100%). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a clear visualization of profit analysis?",
+      "description": "Check if the tool includes visualizations (charts, graphs) showing profit breakdown, contribution margins, or break-even analysis. Score 0 if no visualizations are present, 5 if basic charts are implemented but lack interactivity or clarity, and 10 if comprehensive, interactive visualizations with proper labeling and color-coding are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the tool include scenario comparison or sensitivity analysis?",
+      "description": "Assess whether the code allows users to compare different pricing strategies, product mixes, or perform what-if analyses. Check if the tool can save multiple scenarios and display side-by-side comparisons. Deduct 5 points if only single-scenario calculations are supported. The full score is 10 points if users can interactively adjust variables and see immediate impact on profitability.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, type errors, division by zero, 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. Tax optimization suggestions 2. Dynamic pricing recommendations based on profitability targets 3. Export functionality to CSV/PDF). 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 calculations (e.g., multiple profit formulas that do the same thing) 2. Function modules unrelated to profit calculation (e.g., unnecessary product catalog features) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating calculation logic/view/data management layers), 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 validation or sanitization of inputs. 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) Real-time calculation updates as values change 2) Transition animation duration controlled between 300-500ms when updating visuals 3) Clear visual feedback for input errors. Deduct 5 points for delayed calculation feedback, 3 points for jarring visual updates when recalculating, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "hard"
+}

package/library/utility_tools-calculation_tools/frame-beam-rebar-length-calculator-webpage.json

@@ -0,0 +1,68 @@
+{
+  "index": 1109,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the generated code is executable for demonstration purposes. According to the 22G standard design code, help me design a web page that calculates the length of upper and lower reinforcing steel bars in frame beams.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the beam reinforcement calculation model correctly implemented?",
+      "description": "Review whether the code accurately implements the mathematical model for calculating upper and lower reinforcing steel bar lengths according to the 22G standard. Check if the formula includes critical parameters such as beam span, section dimensions, hook lengths, and bend radius. Score 0 if the core calculation logic is missing, 5 if basic calculations are implemented but missing some 22G standard requirements, and 10 if fully compliant with the 22G standard specifications.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all required input parameters for reinforcement calculation included?",
+      "description": "Evaluate whether the interface captures all necessary parameters: beam span, beam width, beam height, concrete cover, bar diameter, number of bars, anchorage lengths, and support dimensions. Deduct 2 points for each missing critical parameter. Check if the input fields have appropriate constraints, validation, and unit indicators. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there visual representation of the frame beam and reinforcement?",
+      "description": "Assess if the code includes dynamic visualization (using SVG/Canvas/WebGL) that shows the frame beam with accurately positioned reinforcement bars. The visualization should update based on user inputs and show both longitudinal view and cross-section view. Deduct 5 points if only static images are used, 3 points if the visualization doesn't update with parameter changes, and 2 points if the reinforcement is not drawn to scale. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the calculation include detailed itemized results?",
+      "description": "Check whether the results show a detailed breakdown of the steel bar lengths: straight portions, bent portions, hooks/anchors, and total quantities for both upper and lower reinforcements. Deduct 3 points if only final totals are shown without itemization, 2 points if material wastage estimation is missing, and 2 points if results don't include unit conversion options. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, edge cases like extremely small/large dimensions, conflicts in reinforcement arrangement, 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. Bill of materials export function 2. Multiple layout configuration templates 3. Real-time cost estimation). 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 calculation methods 2. Function modules unrelated to structural engineering (e.g., a built-in general calculator) 3. Decorative elements that affect performance without adding value. 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 calculation logic/view/data validation layers), code documentation, 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 are no comments explaining the engineering formulas or 22G standard references. 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) Real-time calculation updates when parameters change 2) Smooth transitions when visualization updates 3) Clear visual feedback for user actions. Deduct 5 points for delayed calculation feedback (>500ms), 3 points for jumpy visualization updates, and 5 points for hidden or confusing engineering controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "medium"
+}