@getollie/cli 0.0.4 → 0.2.0

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

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

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

@@ -1,68 +0,0 @@
-{
-  "index": 602,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable whenever possible. Design a currency exchange rate calculator that allows users to input an amount and currency, then displays real-time conversion results based on their selected target currency, and supports querying historical exchange rate records by date.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core currency conversion functionality fully implemented?",
-      "description": "Review whether the code implements accurate currency conversion with real-time exchange rates fetching. Check if the application properly handles currency input, selection, and result display with appropriate decimal precision. Score 0 if core conversion is missing, 5 if basic conversion exists without real-time rates, and 10 if fully implemented with accurate exchange rate API integration.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the historical exchange rate querying feature implemented?",
-      "description": "Evaluate whether users can select specific dates and retrieve historical exchange rates. Check if the application includes date validation, proper handling of non-trading days, and visualization of historical data (tables or charts). Deduct 5 points if only current-day lookups are possible, and 3 points if date selection exists but validation is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the exchange rate data source properly implemented and managed?",
-      "description": "Check whether the application connects to a reliable exchange rate API, implements proper error handling for API failures, and includes a fallback mechanism (like cached rates). Verify if rate updates occur at appropriate intervals without excessive API calls. Deduct 5 points for missing API error handling, 3 points for no caching strategy. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are currency selection and input validation properly implemented?",
-      "description": "Review whether the application provides a comprehensive list of currencies with appropriate symbols/codes, implements input validation for amounts (preventing negative values, non-numeric inputs), and handles currency selection changes correctly. Deduct 3 points for missing validation, 4 points for incomplete currency options, and 3 points for improper handling of selection changes. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as API failures, network interruption, invalid user inputs, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Currency trend visualization 2. Favorite currency pairs saving 3. Rate alerts/notifications when thresholds are met). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple API calls for the same data) 2. Function modules unrelated to currency exchange (e.g., unnecessary weather widgets) 3. Fancy effects that affect performance (e.g., excessive animations during simple conversions). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating API services/UI components/state management), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Currency selection and conversion calculation response ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual feedback when rates update or calculations complete. Deduct 5 points for each operation without feedback, 3 points for laggy responses during currency switching, and 5 points for confusing interaction flows. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "easy"
-}

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

@@ -1,68 +0,0 @@
-{
-  "index": 1570,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration purposes. Help me create an e-commerce profit calculation tool.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core profit calculation functionality fully implemented?",
-      "description": "Review whether the code accurately implements the fundamental profit calculation formulas (Revenue - COGS - Expenses), with proper handling of different units (currency, percentages). Score 0 if the core calculation is not implemented, 5 if basic calculations are present but missing important metrics like margins or ROI, and 10 if all essential e-commerce metrics (gross/net profit, margins, ROI, break-even analysis) are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the tool provide comprehensive input handling for e-commerce variables?",
-      "description": "Evaluate whether the code handles all necessary e-commerce variables: product costs, selling price, shipping fees, payment processing fees, marketing costs, returns/refunds rate, taxes, and operational costs. Deduct 2 points for each critical missing variable. Check if validation is in place to prevent nonsensical inputs (negative prices, percentages over 100%). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a clear visualization of profit analysis?",
-      "description": "Check if the tool includes visualizations (charts, graphs) showing profit breakdown, contribution margins, or break-even analysis. Score 0 if no visualizations are present, 5 if basic charts are implemented but lack interactivity or clarity, and 10 if comprehensive, interactive visualizations with proper labeling and color-coding are implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the tool include scenario comparison or sensitivity analysis?",
-      "description": "Assess whether the code allows users to compare different pricing strategies, product mixes, or perform what-if analyses. Check if the tool can save multiple scenarios and display side-by-side comparisons. Deduct 5 points if only single-scenario calculations are supported. The full score is 10 points if users can interactively adjust variables and see immediate impact on profitability.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, type errors, division by zero, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Tax optimization suggestions 2. Dynamic pricing recommendations based on profitability targets 3. Export functionality to CSV/PDF). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar calculations (e.g., multiple profit formulas that do the same thing) 2. Function modules unrelated to profit calculation (e.g., unnecessary product catalog features) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating calculation logic/view/data management layers), unit test coverage, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no validation or sanitization of inputs. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Real-time calculation updates as values change 2) Transition animation duration controlled between 300-500ms when updating visuals 3) Clear visual feedback for input errors. Deduct 5 points for delayed calculation feedback, 3 points for jarring visual updates when recalculating, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "hard"
-}

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

@@ -1,68 +0,0 @@
-{
-  "index": 1109,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the generated code is executable for demonstration purposes. According to the 22G standard design code, help me design a web page that calculates the length of upper and lower reinforcing steel bars in frame beams.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the beam reinforcement calculation model correctly implemented?",
-      "description": "Review whether the code accurately implements the mathematical model for calculating upper and lower reinforcing steel bar lengths according to the 22G standard. Check if the formula includes critical parameters such as beam span, section dimensions, hook lengths, and bend radius. Score 0 if the core calculation logic is missing, 5 if basic calculations are implemented but missing some 22G standard requirements, and 10 if fully compliant with the 22G standard specifications.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all required input parameters for reinforcement calculation included?",
-      "description": "Evaluate whether the interface captures all necessary parameters: beam span, beam width, beam height, concrete cover, bar diameter, number of bars, anchorage lengths, and support dimensions. Deduct 2 points for each missing critical parameter. Check if the input fields have appropriate constraints, validation, and unit indicators. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there visual representation of the frame beam and reinforcement?",
-      "description": "Assess if the code includes dynamic visualization (using SVG/Canvas/WebGL) that shows the frame beam with accurately positioned reinforcement bars. The visualization should update based on user inputs and show both longitudinal view and cross-section view. Deduct 5 points if only static images are used, 3 points if the visualization doesn't update with parameter changes, and 2 points if the reinforcement is not drawn to scale. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the calculation include detailed itemized results?",
-      "description": "Check whether the results show a detailed breakdown of the steel bar lengths: straight portions, bent portions, hooks/anchors, and total quantities for both upper and lower reinforcements. Deduct 3 points if only final totals are shown without itemization, 2 points if material wastage estimation is missing, and 2 points if results don't include unit conversion options. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, edge cases like extremely small/large dimensions, conflicts in reinforcement arrangement, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Bill of materials export function 2. Multiple layout configuration templates 3. Real-time cost estimation). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar calculation methods 2. Function modules unrelated to structural engineering (e.g., a built-in general calculator) 3. Decorative elements that affect performance without adding value. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating calculation logic/view/data validation layers), code documentation, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments explaining the engineering formulas or 22G standard references. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Real-time calculation updates when parameters change 2) Smooth transitions when visualization updates 3) Clear visual feedback for user actions. Deduct 5 points for delayed calculation feedback (>500ms), 3 points for jumpy visualization updates, and 5 points for hidden or confusing engineering controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "medium"
-}

package/library/utility_tools-calculation_tools/geometric-calculation-tool-with-visual-preview.json

@@ -1,68 +0,0 @@
-{
-  "index": 644,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Design a geometric calculation tool that supports common plane figures (circle, triangle, rectangle, regular polygon, etc.) and solid figures (sphere, cylinder, cone, prism, etc.) for calculating area, perimeter, volume and surface area. Users can select the type of shape, input necessary parameters (such as side length, radius, height, etc.), and obtain calculation results. The tool needs to provide interactive graphical preview that updates the shape diagram in real time based on user input and labels key dimensions. It should also provide options to show or hide calculation formulas.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Are all required geometric figures and their calculations properly implemented?",
-      "description": "Evaluate whether the code accurately implements calculation functions for all required plane figures (circle, triangle, rectangle, regular polygon) and solid figures (sphere, cylinder, cone, prism). Score 0 if fewer than 50% of requested shapes are implemented, 5 if basic shapes are implemented but with limited functionality, and 10 if all shapes are implemented with complete calculation logic for area, perimeter, volume, and surface area as applicable.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the parameter input system comprehensive and validated?",
-      "description": "Check whether the input system allows users to specify all necessary parameters for each shape (side lengths, radius, height, etc.) with appropriate constraints and validations. Deduct 3 points if input validation is missing, 3 points if negative or invalid values are allowed, and 2 points if unit selection is not available. Give 10 points if the input system is robust, validates all inputs, provides clear error messages, and includes appropriate units.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the interactive graphical preview functionality properly implemented?",
-      "description": "Assess whether the tool provides real-time visual updates of shapes based on user input. The preview should accurately represent proportions and dimensions. Deduct 5 points if the visualization doesn't update in real-time, 3 points if dimensions aren't labeled, and 5 points if the graphical representation is inaccurate or misleading. Full score requires SVG or Canvas-based responsive diagrams that precisely reflect input parameters.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the tool provide formula visibility options as requested?",
-      "description": "Evaluate whether users can show/hide calculation formulas for each shape. The formulas should be mathematically correct and presented in a readable format (e.g., MathJax/LaTeX or clear text formatting). Deduct 5 points if formulas cannot be toggled on/off, 3 points if formulas are incorrect, and 3 points if formula presentation is poorly formatted or difficult to read. Full score requires elegant formula display with proper mathematical notation.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, edge cases like zero dimensions, floating-point precision issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. 3D rotation for solid figures 2. Exporting calculations as PDF/image 3. Comparison mode for multiple shapes 4. Animation showing volume filling or area coverage). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar calculations (e.g., multiple area calculation methods for the same shape) 2. Function modules unrelated to geometric calculation (e.g., unnecessary animations) 3. Fancy effects that affect performance or usability. 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/visualization/UI layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or appropriate design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between calculation logic and presentation. 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) Input feedback delay ≤ 100ms 2) Visual updates occur promptly after parameter changes 3) Clear visual focus guidance between input and output elements. Deduct 5 points for each operation without feedback, 3 points for laggy visualization updates, and 5 points for confusing interaction patterns or hard-to-find controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "medium"
-}

package/library/utility_tools-calculation_tools/html-css-js-simulated-clock.json

@@ -1,68 +0,0 @@
-{
-  "index": 1396,
-  "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 and can be demonstrated. Write a simulated clock using HTML, CSS, and JavaScript.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the clock display mechanism accurately implemented?",
-      "description": "Review whether the code accurately implements real-time display through HTML/CSS/JavaScript, including precise hour/minute/second hand positioning, correct time calculation logic, and proper coordinate system for analog clock face. Score 0 if basic time display is not working, 5 if only digital time is shown, and 10 if both analog and digital clocks are perfectly synchronized with accurate mathematical calculations for hand angles.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the real-time update functionality properly implemented?",
-      "description": "Check whether the JavaScript implementation includes efficient timing mechanisms (setInterval/requestAnimationFrame), smooth animation transitions for clock hands, and proper memory management to prevent performance degradation. Deduct 5 points if timing drift occurs after extended running, and 3 points if animations are choppy or inconsistent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are multiple time formats and display modes supported?",
-      "description": "Evaluate whether the clock supports different time formats (12/24 hour), multiple timezone displays, and various visual styles (analog/digital/hybrid). Check if timezone conversion is mathematically correct and if format switching works seamlessly. Deduct 5 points if timezone calculations are incorrect, and 3 points if format switching causes display glitches. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is comprehensive clock customization functionality provided?",
-      "description": "Check whether the code includes customization options such as theme switching, size adjustment, color schemes, and clock face styles. Evaluate if settings persist across sessions and if customization affects performance. Deduct 5 points if customization options don't save properly, and 3 points if theme changes cause layout breaks. Give 10 points if fully implemented with smooth transitions.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as system time changes, browser tab switching, invalid date inputs, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should effectively handle edge cases like leap seconds, daylight saving time transitions, and browser compatibility issues, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Alarm/timer functionality with custom sounds 2. World clock with multiple timezones 3. Stopwatch with lap timing 4. Pomodoro timer integration 5. Voice time announcements). 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 timing functions (e.g., multiple interval timers coexisting) 2. Function modules unrelated to clock functionality (e.g., built-in calculator or weather widget) 3. Excessive visual effects that impact performance (e.g., complex particle systems or heavy animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if core clock 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 time logic/display/animation layers), performance optimization techniques, and code maintainability. Deduct 5 points if global state pollution is found or proper separation of concerns is missing; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if performance optimization opportunities are missed (e.g., unnecessary DOM manipulations). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the clock design follows modern design principles: 1) Harmonious color matching with proper contrast ratios 2) Proportional layout with appropriate sizing for readability 3) Professional typography with clear numerals and markers 4) Consistent visual hierarchy. Deduct 3 points for each poorly readable element, 5 points for jarring color combinations that strain the eyes, and 5 points for disproportional or cramped layouts. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the animation smooth and mathematically accurate?",
-      "description": "Judge whether the clock animations conform to realistic movement: 1) Second hand moves with proper timing (smooth or ticking motion) 2) Hour and minute hands transition smoothly with correct angular calculations 3) No visual stuttering or frame drops during continuous operation 4) Proper easing functions for natural movement. Deduct 5 points for each jerky or inaccurate hand movement, 3 points for mathematical errors in angle calculations, and 5 points for performance issues during extended operation. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "medium"
-}

package/library/utility_tools-calculation_tools/html-geometric-drawing-board-with-measurements.json

@@ -1,68 +0,0 @@
-{
-  "index": 369,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Help me create an HTML file with a geometric drawing board functionality that supports drawing shapes, measuring lengths, and angles.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the geometric shape drawing functionality fully implemented?",
-      "description": "Review whether the code accurately implements multiple geometric shape drawing through HTML5 Canvas/SVG, including basic shapes (lines, circles, rectangles, polygons) and advanced shapes (bezier curves, arcs). Check if the drawing implements precise coordinate tracking, real-time preview during drawing, and shape completion validation. Score 0 if core drawing logic is missing, 5 if only basic shapes are implemented, and 10 if comprehensive geometric shapes with smooth drawing experience are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the length and angle measurement system accurately implemented?",
-      "description": "Evaluate whether the measurement tools include pixel-to-unit conversion, real-time distance calculation between points, angle measurement with visual indicators, and measurement result display with appropriate precision (2-3 decimal places). Check if measurement tools provide visual feedback with measurement lines/arcs overlay. Deduct 5 points if measurement accuracy is below 95%, and 3 points if visual measurement indicators are unclear. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the interactive drawing board control system well-designed?",
-      "description": "Check whether the drawing board includes comprehensive control mechanisms: shape selection tools, undo/redo functionality, clear canvas option, zoom in/out capabilities, and pan/drag canvas functionality. Evaluate if mouse/touch event handling supports both desktop and mobile interactions. Deduct 5 points if undo/redo is missing, 3 points if zoom functionality is not smooth, and 2 points if mobile touch support is inadequate. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the drawing state management and persistence properly constructed?",
-      "description": "Evaluate whether the code implements drawing state management including save/load drawings to localStorage, export functionality (PNG/SVG format), and drawing history tracking. Check if the system maintains drawing layer management and shape property editing capabilities. Deduct 5 points if save/load functionality is missing, 3 points if export quality is poor, and 2 points if drawing history is not maintained. Give 10 points if fully implemented with robust state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid coordinate input, canvas size overflow, unsupported browser features, memory leaks during extensive drawing, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases including canvas performance optimization for complex drawings. Give 10 points for excellent robustness, 5 points for average handling, and 0 points if no exceptions are handled.",
-      "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 drawing experience (e.g., 1. Grid snap functionality with customizable grid size 2. Shape templates library 3. Color palette with custom color mixing 4. Geometric construction tools like compass and ruler simulation 5. Real-time coordinate display). Add 2-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 drawing functions (e.g., multiple circle drawing methods coexisting) 2. Function modules unrelated to geometric drawing (e.g., built-in games or unrelated utilities) 3. Fancy effects that affect drawing performance (e.g., excessive animations during drawing). Deduct 3 points for each redundancy found, and directly deduct 10 points if core drawing 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 drawing engine/UI controls/measurement tools), code organization with clear separation of concerns, and proper event handling architecture. Deduct 5 points if global state pollution is found or no design patterns are used; deduct 5 points if code duplication rate is too high (over 25%); deduct 3 points if drawing performance is not optimized for complex scenes. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the drawing board interface follows modern design principles: 1) Intuitive tool palette with clear iconography 2) Proper contrast between canvas and UI elements 3) Consistent spacing and alignment (following 8px grid system) 4) Professional color scheme with adequate visual hierarchy. Deduct 3 points for each cluttered UI element, 5 points for poor color contrast affecting usability, and 5 points for inconsistent visual design language. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the drawing interactions conform to user expectations: 1) Drawing response delay ≤ 50ms for smooth line drawing 2) Tool switching feedback within 100ms 3) Smooth zoom/pan operations without lag 4) Clear visual feedback for all interactive elements 5) Intuitive cursor changes for different tools. Deduct 5 points for each laggy drawing operation, 3 points for unclear tool state indication, and 5 points for poor drawing smoothness on high-resolution displays. Full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "hard"
-}

package/library/utility_tools-calculation_tools/indented-tree-layout-algorithm-javascript-canvas.json

@@ -1,68 +0,0 @@
-{
-  "index": 332,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you provide is executable for demonstration. Implement an indented tree layout algorithm using JavaScript and Canvas.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the tree layout algorithm correctly implemented?",
-      "description": "Evaluate whether the algorithm correctly positions tree nodes with proper indentation levels. Check if it handles parent-child relationships correctly, maintains proper horizontal spacing between sibling nodes, and ensures vertical spacing between different tree levels. Score 0 if the algorithm fails to create a basic tree structure, 5 if it creates a basic structure with minor positioning issues, and 10 if it implements a complete indented tree layout with proper spacing and alignment.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is Canvas rendering implemented properly?",
-      "description": "Assess the Canvas API implementation for rendering the tree. Check if it correctly draws nodes (rectangles/circles), connection lines between parent-child nodes, and handles text rendering within nodes. Verify proper use of context methods like beginPath(), stroke(), fill(), etc. Score 0 if Canvas rendering is missing or fundamentally broken, 5 if basic rendering exists with minor visual glitches, and 10 if rendering is complete with clean visuals and proper Canvas state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the implementation handle varied tree data structures?",
-      "description": "Check if the implementation can process different tree data formats (nested objects, adjacency lists, etc.) and tree sizes. Verify if it can handle edge cases such as single-node trees, deeply nested trees, and unbalanced trees with varying numbers of children. Score 0 if only one specific format is supported with no flexibility, 5 if it handles common formats but has limitations, and 10 if it's adaptable to multiple data structures with comprehensive edge case handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are there performance optimizations for large trees?",
-      "description": "Evaluate whether the implementation includes optimizations for handling large trees, such as viewport culling (only rendering visible nodes), level-of-detail rendering, or efficient node positioning algorithms. Check for evidence of time complexity analysis or benchmarking. Deduct 5 points if rendering becomes noticeably slow with more than 100 nodes, and 3 points if there's no consideration for performance with large datasets. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid input data, missing node properties, circular references in the tree, 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. Interactive node expansion/collapse 2. Node search/filtering capabilities 3. Zoom and pan functionality 4. Animated transitions when rearranging nodes). 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 calculations in the layout algorithm 2. Unnecessary re-rendering of the entire tree when only portions change 3. Fancy effects that affect performance without adding value to the tree visualization. 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 layout algorithm, rendering logic, and data management), code reusability, and adherence to design patterns. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation between core algorithms and rendering code. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the visual representation meet professional visualization standards?",
-      "description": "Evaluate whether the tree visualization follows data visualization principles: 1) Clear node differentiation and hierarchy representation 2) Appropriate use of color for encoding information (not merely decorative) 3) Sufficient contrast between nodes and background. Deduct 3 points for cluttered layouts, 5 points for poor visual hierarchy, and 5 points for illegible node text or unclear relationship lines. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the interaction with the tree visualization intuitive and responsive?",
-      "description": "Judge whether the interaction mechanisms (if implemented) conform to user expectations: 1) Click/hover feedback delay ≤ 100ms 2) Smooth animations for expanding/collapsing nodes (duration between 200-400ms) 3) Intuitive controls for any pan/zoom functionality. Deduct 5 points for each interaction without feedback, 3 points for choppy animations, and 5 points for non-intuitive interaction patterns. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Calculation Tools",
-  "difficulty": "medium"
-}