@getollie/cli 0.0.4 → 0.2.0

package/library/utility_tools-calculation_tools/interactive-calculator.json

@@ -1,68 +0,0 @@
-{
-  "index": 959,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the code you generate is executable and demonstrable. Create an interactive calculator.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the basic calculator functionality fully implemented?",
-      "description": "Check whether the code implements all basic arithmetic operations (addition, subtraction, multiplication, division), with proper handling of decimal points and operator precedence. Score 0 if operations are missing, 5 if basic operations work but have precedence issues, and 10 if all operations work correctly with proper PEMDAS implementation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are advanced calculator features included?",
-      "description": "Evaluate whether the calculator includes scientific functions (sin, cos, tan, log, etc.), memory functions (M+, M-, MR, MC), and conversion capabilities (degrees/radians, different number bases). Deduct 3 points if scientific functions are absent, 3 points if memory functions are missing, and 4 points if no conversions are available. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is input validation and error handling properly implemented?",
-      "description": "Assess how the calculator handles invalid inputs (like division by zero, improper syntax, overflow/underflow). Check for clear error messages and graceful error recovery. Deduct 5 points if the calculator crashes on invalid input, 3 points if errors occur without user notification, and 2 points if error messages are technical rather than user-friendly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is calculation history functionality provided?",
-      "description": "Check if the calculator maintains a history of calculations that users can review, recall, or reuse. Verify if the history persists between sessions using local storage. Deduct 5 points if history functionality is completely absent, 3 points if history exists but can't be interacted with, and 2 points if history doesn't persist between sessions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid consecutive clicks, keyboard and mouse input combinations, or browser-specific issues) 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. Voice input/output 2. Customizable themes/layouts 3. Formula visualization with graphs). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to perform the same calculation) 2. Function modules unrelated to calculation (e.g., unnecessary widgets or distractions) 3. Fancy effects that affect performance (e.g., excessive animations that slow input response). 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/UI/event handling), 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 (button text size ≥ 14px, proper contrast between numbers and background). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for misaligned buttons or inconsistent spacing. 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) Button press/release feedback ≤ 50ms 2) Visual feedback on operation success/failure 3) Clear state indication (current operation, memory status, etc.). Deduct 5 points for each operation without feedback, 3 points for laggy response when entering multiple digits quickly, and 5 points for confusing state transitions between operations. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "easy"
-}

package/library/utility_tools-calculation_tools/javascript-timer-function-setup.json

@@ -1,68 +0,0 @@
-{
-  "index": 1057,
-  "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. Based on the student's actual needs and preferences in a self-directed learning context, provide me with code for setting up a timer function.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Timer Interface Implementation",
-      "description": "Review whether the code accurately implements the core timer functionality with proper display of hours, minutes, and seconds. Check if the timer shows correct numerical values and updates in real-time.Score 0 if the timer doesn't work at all, 5 if it only shows basic counting without proper formatting, 10 if it fully implements a professional time display with proper formatting and precision.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Timer Controls Functionality",
-      "description": "Evaluate if the code includes complete control functions: start, pause, reset, and possibly lap/split times. Test edge cases like rapid clicking of controls and verify proper state management between different control actions.Deduct 3 points if any basic control is missing, 2 points if controls don't handle edge cases, and 3 points if state transitions between controls are buggy. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Timer Accuracy and Performance",
-      "description": "Assess the timer's accuracy over time and its performance impact. Check if the implementation uses efficient methods like requestAnimationFrame or setInterval with drift compensation instead of naive setTimeout chains.Deduct 5 points for timer drift exceeding 1 second per minute of running time, 3 points for inefficient implementation causing performance issues, 2 points if the timer fails after extended periods. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Configuration Options and Flexibility",
-      "description": "Check if the timer allows customization like countdown mode, different time formats (12/24-hour), alert/notification features, or custom interval settings for specialized timing needs in self-directed learning contexts.Award 2 points for each well-implemented configuration option (countdown ability, formats, alerts, intervals, etc.) up to a maximum of 10 points. Score 0 if no customization is available.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Code Robustness",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as browser tab switching, sleep mode, input validation, etc.) and provide recovery mechanisms. Test with browser refresh scenarios and system sleep/wake cycles.Code with strong robustness handling all edge cases gets 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Innovative Features",
-      "description": "Check whether the code includes features that enhance self-directed learning (e.g., 1. Pomodoro technique integration 2. Learning session tracking/statistics 3. Focus mode with website blocking 4. Voice commands for hands-free control).Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Redundant Features",
-      "description": "Strictly check for three types of redundancy: 1. Multiple implementations of the same timing logic 2. Unnecessary features unrelated to timing functionality 3. Excessive animations or effects that impact performance or distract from learning.Deduct 3 points for each redundancy found, and directly deduct 10 points if the core timing functions are negatively affected by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Code Engineering Quality",
-      "description": "Review modular design (separating timer logic from UI), code organization, naming conventions, and potential for extension. Check for proper error handling and cleanup to prevent memory leaks.Deduct 5 points if global state pollution exists; deduct 3 points if code reusability is poor; deduct 2 points if variable naming is unclear or inconsistent. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Interface Visual Design",
-      "description": "Evaluate whether the timer follows good design principles: 1) Clear readable typography (especially for time display) 2) Proper contrast between elements 3) Intuitive layout with sufficient spacing 4) Responsive design for different screen sizes.Deduct 3 points for poor readability of time display, 3 points for confusing layout, 2 points for non-responsive design, and 2 points for inadequate visual hierarchy. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Interaction Experience",
-      "description": "Judge whether the timer provides good interaction feedback: 1) Visual/audio cues when timer starts/stops/completes 2) Accessible controls with keyboard shortcuts 3) Smooth transitions between timer states 4) Intuitive controls that match user expectations.Deduct 3 points for missing feedback on timer state changes, 2 points for inaccessible controls, 3 points for jarring visual transitions, and 2 points for counterintuitive control placement. Full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "easy"
-}

package/library/utility_tools-calculation_tools/large-language-model-simple-calculator.json

@@ -1,68 +0,0 @@
-{
-  "index": 799,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Pay attention to ensuring that the generated code is executable. I am not a programmer, and I would like to use a large language model to write a simple calculator app. Is this possible?",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core calculator functionality fully implemented?",
-      "description": "Review whether the calculator can correctly perform basic arithmetic operations (addition, subtraction, multiplication, division). Check for proper order of operations (PEMDAS), decimal handling, and error prevention for division by zero. Score 0 if calculations are incorrect, 5 if basic operations work but with edge case issues, and 10 if all operations work flawlessly with proper error handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the user interface properly implemented?",
-      "description": "Assess the quality of the calculator UI implementation, including proper button layout, input display area, and visual feedback for button presses. Check if the calculator has a clear display for both input and output. Deduct 5 points if the layout is confusing or inconsistent, and 3 points if visual feedback is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the calculator handle user input correctly?",
-      "description": "Evaluate how well the application processes user interactions, including handling consecutive operations, clearing inputs, and managing decimal inputs. Check if the calculator prevents invalid input sequences. Deduct 5 points if it allows impossible mathematical expressions, and 3 points if it doesn't provide input validation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the implementation beginner-friendly?",
-      "description": "Assess if the code is well-commented and structured in a way that a non-programmer can understand and modify it. Check if there are clear explanations of how to run the code and how different parts work. Score 0 if no explanations exist, 5 if basic comments are present but insufficient, and 10 if comprehensive guidance is provided.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, unexpected user behavior, 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. Memory functions 2. History of calculations 3. Theme switching or customization). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to clear input) 2. Function modules unrelated to a calculator (e.g., unnecessary animations) 3. Overly complex code for simple operations. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating UI/logic layers), code organization, and maintainability. Deduct 5 points if global state is poorly managed; deduct 5 points if the code is difficult to extend or modify; deduct 5 points if there's no clear structure or organization. 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 input sequences, 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/lottery-number-filter-welfare-lottery-3d.json

@@ -1,68 +0,0 @@
-{
-  "index": 1342,
-  "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. Can you help me create a lottery number filter for the Welfare Lottery 3D game, similar to the functionality in the \"Number Calculator\" app?",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the basic 3D lottery filtering functionality implemented?",
-      "description": "Check whether the code includes core filtering functions for Welfare Lottery 3D (000-999): digit-specific filters (odd/even, big/small), sum value filters, span value filters, and group/repeat number checks. Score 0 if basic filtering is missing, 5 if only simple filters are implemented, and 10 if comprehensive filtering logic matching professional lottery apps is present.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the implementation include advanced statistical analysis features?",
-      "description": "Evaluate whether the code provides statistical analysis tools such as frequency charts, historical trend analysis, hot/cold number identification, and probability calculations. Deduct 3 points if basic frequency analysis is missing, 5 points if historical data comparison is absent, and 2 points if probability calculations are inaccurate or missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a comprehensive number combination generator with constraints?",
-      "description": "Assess whether the code can generate number combinations based on multiple filter conditions simultaneously, with optimization for performance when generating large sets. Check if the generator can handle complex condition combinations without duplication. Deduct 5 points if the generator doesn't support multiple constraints, 3 points if performance degrades with >1000 combinations, and 2 points if duplicates aren't eliminated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is historical data management and import/export functionality included?",
-      "description": "Check if the code includes functionality to import historical lottery results, save user-defined filters, and export filtered number sets. The system should allow data import from CSV/Excel or direct web scraping from official lottery sites. Deduct 5 points if import/export is missing, 3 points if saved filters cannot be reused, and 2 points if there's no batch operation support. 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, unexpected format in imported data, network issues during data fetching, 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. AI-based number recommendation 2. Visual pattern recognition in historical data 3. Personalized filtering strategy based on user history). 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 filtering functions 2. Function modules unrelated to lottery analysis (e.g., a built-in general calculator) 3. Fancy effects that affect performance (e.g., unnecessary animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating data processing/UI/storage layers), algorithm optimization for lottery calculations, and code 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 algorithm complexity is not optimized for lottery operations. 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) Filter application feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual guidance for filter selection and results. Deduct 5 points for each operation without feedback, 3 points for visual stuttering during number generation, 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/maui-calculator-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1183,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, expert responses. Ensure that any code you generate is executable and demonstrable. Write a calculator using Maui.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the MAUI calculator UI layout properly implemented?",
-      "description": "Evaluate whether the code implements a responsive grid layout for the calculator buttons that adapts to different screen sizes and orientations. Check for proper margins, padding, and alignment of elements. Score 0 if there's no proper layout implementation, 5 if basic layout exists but doesn't handle different screen sizes well, and 10 if the layout is responsive and visually balanced across devices.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all core calculator functions implemented?",
-      "description": "Review whether the implementation includes all standard calculator operations (addition, subtraction, multiplication, division), as well as additional functions like percentage, square root, memory operations, etc. Ensure proper implementation of decimal point handling and operator precedence. Deduct 2 points for each missing core function and 1 point for each incorrect implementation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the calculation engine properly designed and separated from UI logic?",
-      "description": "Check if the solution follows MVVM pattern with clean separation between the calculation engine and UI. Evaluate whether the code uses proper data binding between the ViewModel and View. Deduct 5 points if there's no clear separation of concerns, 3 points if data binding is implemented incorrectly, and 2 points if state management is problematic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the calculator handle input validation and error conditions?",
-      "description": "Assess how the code handles edge cases like division by zero, overflow/underflow, invalid input sequences (e.g., multiple operators in sequence), and large number handling. Check for user feedback on errors. Score 0 if there's no error handling, 5 if basic validation exists but lacks comprehensive coverage, and 10 if all common calculator errors are properly handled with clear user feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid button presses, unexpected input sequences, or app state changes during calculations) 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. Scientific calculator mode 2. Calculation history tracking 3. Customizable themes or button layouts 4. Unit conversion capabilities). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to perform the same calculation) 2. Function modules unrelated to a calculator (e.g., built-in games or unrelated tools) 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/services), 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) Button press feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual indication of button presses and calculation results. Deduct 5 points for each operation without feedback, 3 points for sluggish UI responses during calculations, and 5 points for confusing state transitions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "easy"
-}

package/library/utility_tools-calculation_tools/mini-program-tensile-resistance-anchor-bolts.json

@@ -1,68 +0,0 @@
-{
-  "index": 1555,
-  "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. Create a mini-program that calculates the tensile resistance of anchor bolts according to the \"Technical Code for Building Pile Foundations,\" configure a UI, and ensure it can run directly.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core calculation function for anchor bolt tensile resistance implemented correctly?",
-      "description": "Review whether the code accurately implements the calculation formulas based on the 'Technical Code for Building Pile Foundations'. Check if all required parameters are included (such as anchor diameter, embedded depth, concrete strength, etc.) and if the calculations follow the standard equations. Score 0 if calculations are missing, 5 if basic calculations are implemented but with errors, and 10 if all formulas are correctly implemented according to the technical code.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all necessary input parameters and their constraints handled properly?",
-      "description": "Evaluate whether the program accepts all required parameters for accurate tensile resistance calculation. Check if the code validates input ranges according to the technical standards (e.g., minimum/maximum values for bolt diameters, concrete strength grades). Deduct 3 points for each missing critical parameter, 2 points for inadequate validation, and 5 points if the units of measurement are inconsistent or unclear. Full score for comprehensive parameter handling with proper validation.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the program implement different calculation scenarios as per the technical code?",
-      "description": "Check if the program handles different anchor bolt types, installation methods, and special conditions as specified in the technical code. Score 3 points for each properly implemented scenario (straight anchors, bent anchors, different failure modes). Deduct 5 points if the program only implements a single basic scenario without considering variations. Maximum 10 points for comprehensive coverage.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the user interface properly designed for engineering applications?",
-      "description": "Assess if the UI is designed with engineering professionals in mind. Check for clear labeling of input fields with units, appropriate use of engineering terminology, logical grouping of related inputs, and presentation of results with proper significant figures. Deduct 3 points for confusing terminology, 3 points for poor input organization, and 4 points if results lack proper engineering context or units. Full score for a professional engineering-oriented interface.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle various input errors (non-numeric inputs, out-of-range values, etc.) and edge cases. Check for proper error handling with informative messages that guide users to correct inputs. Deduct 2 points for each unhandled error case, and 5 points if the program crashes on invalid inputs. Give 10 points if robust error handling is implemented throughout.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that enhance usability for engineers?",
-      "description": "Check whether the code includes features that improve workflow efficiency (e.g., 1. Quick result comparison between different parameters 2. Visualization of calculation results 3. Export functionality for reports). 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 implementations of similar calculations 2. Functionality unrelated to anchor bolt calculations 3. Fancy effects that distract from the engineering application. 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 calculation logic from UI), code reusability, and maintainability. Check if the code follows clear naming conventions appropriate for engineering software. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is high; deduct 3 points if variable/function names don't reflect engineering concepts. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional engineering software standards?",
-      "description": "Evaluate whether the design follows professional engineering software principles: 1) Clean, distraction-free interface 2) Clear hierarchy of information 3) Consistent formatting of numerical values and units. Deduct 3 points for each cluttered section, 5 points for poor contrast affecting readability, and 5 points for inconsistent representation of technical information. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the calculation workflow intuitive and efficient?",
-      "description": "Judge whether the application workflow matches how engineers would approach these calculations: 1) Logical progression from inputs to results 2) Ability to quickly modify parameters and recalculate 3) Clear distinction between input, calculation, and output phases. Deduct 4 points for workflows requiring unnecessary steps, 3 points for calculations that don't update promptly after input changes, and 5 points if the calculation process is unclear to users. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "easy"
-}

package/library/utility_tools-calculation_tools/mitigate-harm-unhealthy-foods.json

@@ -1,68 +0,0 @@
-{
-  "index": 1804,
-  "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 when possible. Write a JavaScript program that can provide solutions for mitigating physical harm after users consume unhealthy foods.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core health assessment functionality properly implemented?",
-      "description": "Evaluate whether the code accurately implements algorithms to calculate health impacts from unhealthy food consumption. Check if it includes nutrient analysis, caloric impact estimation, and personalized risk assessment. Score 0 if no assessment logic exists, 5 if basic calorie counting is implemented, and 10 if comprehensive health impact analysis with scientific backing is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are evidence-based mitigation strategies provided?",
-      "description": "Check if the solution offers scientifically-backed mitigation strategies (e.g., specific exercises, nutritional counterbalances, hydration recommendations). Verify if strategies are tied to specific unhealthy food types. Deduct 5 points if recommendations lack scientific citations, 3 points if strategies are generic rather than food-specific. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is user input handling comprehensive and personalized?",
-      "description": "Evaluate the implementation of user input collection for personalization (age, weight, height, existing health conditions, food consumed). Check if BMI calculation and individual factors are considered when providing recommendations. Deduct 5 points if basic physical parameters are missing, 3 points if the system doesn't adapt recommendations based on user profile. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a visualization component for health impact and improvement tracking?",
-      "description": "Assess whether the code includes visual representations (charts, progress trackers, comparison metrics) to help users understand health impacts and track improvement. Check for interactive elements that respond to user input. Deduct 5 points if no visualization exists, 3 points if visualizations are static rather than interactive. 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 user inputs, extreme nutritional values, missing health data, 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. Real-time AI nutritional advice 2. Integration with fitness trackers 3. Social sharing of health improvement milestones). 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 BMI calculation methods) 2. Function modules unrelated to health mitigation (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., unnecessary animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating nutritional analysis/recommendation/visualization 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": "hard"
-}

package/library/utility_tools-calculation_tools/natural-frequency-calculator-gui.json

@@ -1,68 +0,0 @@
-{
-  "index": 848,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Take care to ensure that the generated code is executable for demonstration. Create a GUI section that outputs the first-order natural frequency f1, second-order natural frequency f2, and third-order natural frequency f3.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the natural frequency calculation algorithm correctly implemented?",
-      "description": "Evaluate whether the code accurately implements mathematical formulas for calculating first, second, and third-order natural frequencies. Check for proper use of physics/engineering formulas, correct dimensional analysis, and numerical stability. Score 0 if calculations are incorrect, 5 if basic calculations are implemented with minor issues, and 10 if calculations are mathematically sound with validation checks.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the GUI implementation complete and functional?",
-      "description": "Review whether the code creates a fully functional GUI with clear input fields for required parameters and properly labeled output sections for f1, f2, and f3. Check for essential GUI components (input fields, buttons, result displays). Deduct 5 points if the interface lacks proper layout, 3 points if input validation is missing. Full score requires responsive design and intuitive user flow.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are input parameters properly handled with validation?",
-      "description": "Check whether the code validates user inputs for physical parameters (e.g., mass, stiffness, dimensions) with appropriate constraints, unit conversions, and error handling. Deduct 5 points if validation is minimal, 8 points if completely absent. Full score requires comprehensive validation with helpful error messages and protection against invalid inputs.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there visual representation of the frequency results?",
-      "description": "Assess whether the code includes visual elements (graphs, charts, animations) to represent the calculated natural frequencies. Evaluate quality of visualizations, accuracy of scale, and clarity of presentation. Award 10 points for interactive, well-labeled visualizations that enhance understanding of the frequency relationships; 5 points for basic static representations; 0 points if no visualization is provided.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, calculation errors, edge cases with extreme values) 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. Real-time parameter sensitivity analysis 2. Export functionality for calculated results 3. Interactive mode shape visualization alongside frequencies). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple calculation methods without clear purpose) 2. Function modules unrelated to frequency calculation (e.g., unnecessary analytics) 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/controller layers), 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 the code lacks comments or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the 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) Calculation feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual indication of calculation process and completion. Deduct 5 points for each operation without feedback, 3 points for laggy interface during calculations, and 5 points for confusing workflow. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "easy"
-}