@getollie/cli 0.0.1

package/library/utility_tools-calculation_tools/maui-calculator-implementation.json

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

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

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

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

package/library/utility_tools-calculation_tools/network-diagnostic-tool-visual-ping-bandwidth.json

@@ -0,0 +1,68 @@
+{
+  "index": 542,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure that the generated code is executable for demonstration.\n\n======== ROLE ========\nYou are an experienced code expert. I am providing you with a software development requirement description. Based on these project requirements, please generate the project code. Strictly follow the rules to help users generate complete project code with simple, easy-to-understand language and thorough comments, without outputting anything else.\n\n======== OUTPUT RULES ========\n1. Always generate complete, runnable project code; ensure the project is fully executable\n2. Make sure all code files you output are complete, don't omit any code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot run or contains errors, regenerate it\n4. If the requirements include external API access or user data (images, videos, audio, etc.), please provide mock data\n\n======== PROJECT REQUIREMENTS ========\nDevelop a network diagnostic tool with: 1. Visual Ping route tracing 2. Bandwidth test progress circle 3. Result generation and report sharing 4. Historical record comparison feature 5. Abnormal node map location",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Visual Ping route tracing functionality fully implemented?",
+      "description": "Review whether the code accurately implements a visual ping route tracer with node-by-node path visualization, hop latency metrics, and packet loss indication. Check if the visualization includes an interactive traceroute map showing the network path with proper node representation and connection lines.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Bandwidth test progress circle properly implemented?",
+      "description": "Evaluate the implementation of the bandwidth test progress circle, checking for proper animation, accurate percentage representation, and real-time updating. The component should visually represent download/upload speeds with a circular progress indicator that fills as the test proceeds.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the Result generation and report sharing features complete?",
+      "description": "Check whether the code includes functionality to generate comprehensive diagnostic reports with timestamp, ISP information, and network metrics. Verify if sharing options (direct link, PDF export, social media integration) are implemented and functioning correctly.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the Historical record comparison feature implemented effectively?",
+      "description": "Assess whether the code implements functionality to store, retrieve, and compare historical diagnostic results. Check if the comparative visualization effectively highlights differences between tests, showing performance trends over time.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common network diagnostic scenarios (intermittent connections, timeouts, packet loss) and provide helpful error messaging. Check for proper exception handling, retry mechanisms, and graceful degradation when services are unavailable.",
+      "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 diagnostic experience (e.g., 1. Network health scoring system 2. Predictive performance alerts 3. ISP comparison in your area 4. Interactive topology visualization).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Duplicate network testing methods with overlapping results 2. Functionality unrelated to network diagnostics 3. Performance-intensive visualizations that slow down the core functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separation of network testing logic, data processing, and visualization layers), test coverage for core functions, and build process automation. Check for proper error handling specific to network operations.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the diagnostic tool's UI follows modern dashboard design principles: 1) Clean layout with proper information hierarchy 2) Consistent color scheme for status indicators (red for errors, yellow for warnings, green for normal) 3) Proper data visualization for network metrics with appropriate charts.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the diagnostic tool provides responsive feedback during network operations: 1) Real-time updates during ongoing tests 2) Smooth transitions between test phases 3) Clear progress indicators for long-running operations.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "hard"
+}

package/library/utility_tools-calculation_tools/pension-calculator-social-security-personal-contribution.json

@@ -0,0 +1,68 @@
+{
+  "index": 916,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure the code you generate is executable for demonstration. Help me design a pension calculator that can calculate how much retirement pension one can receive based on local social security and personal contribution circumstances.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the pension calculation logic comprehensive and accurate?",
+      "description": "Evaluate whether the code correctly implements all essential pension calculation formulas, including base salary calculation, years of contribution, contribution rates, and inflation adjustments. Score 0 if calculations are missing or incorrect, 5 if basic calculations are present but lack adjustments for different scenarios, and 10 if the implementation handles multiple pension calculation methods with proper documentation of formulas used.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the calculator handle various contribution scenarios?",
+      "description": "Check if the calculator accommodates different contribution patterns (regular vs. irregular contributions), career breaks, varying contribution rates over time, and different retirement ages. Deduct 3 points if only constant contribution rates are supported, 3 points if it cannot handle contribution gaps, and 4 points if retirement age flexibility is not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are regional/national pension system variations supported?",
+      "description": "Assess whether the code includes configurable parameters for different pension systems, tax treatments, and benefit structures across regions. Score 0 if only one fixed system is implemented, 5 if limited parameterization exists, and 10 if the calculator can be easily configured for multiple national/regional pension systems with different rules and formulas.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there future value projection with economic factors?",
+      "description": "Evaluate if the calculator incorporates economic variables like inflation rates, investment returns for personal contributions, and adjustments for cost of living. Deduct 4 points if inflation is not considered, 3 points if investment growth is simplified/missing, and 3 points if there's no sensitivity analysis for different economic scenarios. 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 negative values, extremely high values, missing inputs, non-numeric inputs, etc.) and provide friendly error prompts or validation 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. Multiple visualization methods for comparing different scenarios 2. Tax optimization suggestions 3. Integration with retirement lifestyle cost calculators). 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 pension calculation (e.g., general financial calculators) 3. Unnecessary complex visualizations that affect performance. 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), unit test coverage, and documentation quality. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments explaining complex pension formulas. 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 form design with clear input labels and appropriate validation messages. Deduct 3 points for each crowded input section, 5 points for confusing result displays, and 5 points for poor information hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and user-friendly?",
+      "description": "Judge whether the calculator provides an intuitive user experience: 1) Real-time calculation updates without page refresh 2) Clear visualization of how input changes affect pension outcomes 3) Mobile responsiveness for different screen sizes. Deduct 5 points for delayed calculation feedback, 3 points for confusing input mechanisms, and 5 points if results are not displayed in an easily understandable format (e.g., both graphical and numerical). The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "hard"
+}

package/library/utility_tools-calculation_tools/production-calculation-calculator-software.json

@@ -0,0 +1,68 @@
+{
+  "index": 1548,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable. Help me create a usable production calculation calculator packaged as software.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic calculation functionality implemented correctly?",
+      "description": "Evaluate whether the calculator includes essential production calculation features: input validation, formula parsing, unit conversion, and result formatting. Score 0 if basic arithmetic operations are missing, 5 if only simple calculations are supported, and 10 if comprehensive production formulas (including rate calculations, efficiency metrics, etc.) are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the software properly packaged for distribution?",
+      "description": "Check if the code includes proper packaging mechanisms (executable generation, installer creation, dependency bundling). Verify if environment-specific configurations are handled, and if cross-platform compatibility is considered where appropriate. Deduct 5 points if the packaging process is manual, 3 points if dependency management is incomplete. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the calculator include industry-specific production formulas?",
+      "description": "Assess whether the calculator incorporates specialized production calculations relevant to manufacturing industries (yield calculations, throughput estimations, cycle time computations, etc.). Deduct 5 points if only generic calculations are available without industry context. Score 10 if comprehensive industry-specific formulas are included with appropriate documentation.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there data persistence and export functionality?",
+      "description": "Evaluate if the calculator can save calculation history, user preferences, and custom formulas. Check for export capabilities to common formats (CSV, PDF, etc.) and integration with other systems. Deduct 5 points if saving is limited to session only, and 3 points if export options are restrictive. 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, division by zero, memory limitations, 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 visualization of calculation trends 2. Template system for common production scenarios 3. Integration with material databases). 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 production calculations (e.g., unnecessary multimedia components) 3. Fancy effects that affect performance (e.g., excessive animations in a calculation tool). 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/data persistence 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) Calculation response time ≤ 100ms 2) Input field navigation and transition smoothness 3) Clear visual feedback for calculation processes. Deduct 5 points for each operation without feedback, 3 points for noticeable lag during complex calculations, and 5 points for unintuitive UI interactions that impede workflow. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "easy"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 1487,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is functional and can be displayed. Using markdown, provide me a calculator for programmers, with the generated HTML consisting of div and script components for each function.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic calculator functionality fully implemented?",
+      "description": "Verify if the code implements all essential calculator operations (addition, subtraction, multiplication, division, modulo) correctly. Check if it handles operand precedence properly and supports parentheses for expression grouping. Score 0 if core calculation logic is missing, 5 if basic operations work but with edge case errors, and 10 if calculations are mathematically accurate in all scenarios.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are programmer-specific functions included?",
+      "description": "Evaluate whether the calculator includes functions essential for programmers: binary/hexadecimal/octal conversions, bitwise operations (AND, OR, XOR, NOT, shifts), logic operations, and possibly scientific functions. Deduct 2 points for each key programmer function missing. Award full points only if the calculator supports multiple number bases and complete set of bitwise operations.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the memory and history functionality implemented?",
+      "description": "Check if the calculator maintains operation history, allows result recall, and includes memory functions (M+, M-, MR, MC). Verify if users can copy results to clipboard and recall previous calculations. Deduct 3 points if history tracking is missing, 3 points if memory operations are absent, and 2 points if clipboard integration is not implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the calculator handle different number systems properly?",
+      "description": "Assess whether the calculator allows seamless switching between decimal, binary, octal, and hexadecimal systems. Verify if it properly displays bit representation, handles signed vs. unsigned integers, and allows bit-length selection (8/16/32/64-bit). Deduct 5 points if conversion between bases has errors, and 5 points if bit manipulation operations don't respect selected bit length.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as division by zero, invalid inputs, overflow/underflow conditions) and provide friendly error prompts. Code with strong robustness should prevent calculation errors through input validation and handle edge cases gracefully. Give 10 points if fully robust, 5 points if some edge cases are unhandled, and 0 points if major calculation errors occur frequently.",
+      "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. Expression syntax highlighting 2. Auto-parentheses balancing 3. Real-time conversion between number systems 4. Customizable keyboard shortcuts). 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 programmer's calculator (e.g., unnecessary graphics) 3. Fancy effects that affect performance. 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/calculation logic/state management), 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; deduct 5 points if there's inadequate error handling or poor code structure. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the UI follows professional calculator design principles: 1) Clear visual hierarchy between number pad and special functions 2) Proper button spacing and sizing for usability 3) Effective use of color to distinguish function groups 4) Clear display area with appropriate font size and contrast. Deduct 3 points for each hard-to-read element, 5 points for inconsistent button styling, and 3 points for poor layout organization. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the calculator provides appropriate feedback: 1) Button press visual feedback ≤ 100ms 2) Clear indication of active mode/base 3) Responsive layout for different screen sizes. Deduct 3 points for each button that lacks visual feedback, 5 points for confusing operation state indicators, and 5 points if the calculator doesn't work properly on mobile devices. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "medium"
+}