@getollie/cli 0.0.1

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

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

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

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

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

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

@@ -0,0 +1,68 @@
+{
+  "index": 959,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the code you generate is executable and demonstrable. Create an interactive calculator.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic calculator functionality fully implemented?",
+      "description": "Check whether the code implements all basic arithmetic operations (addition, subtraction, multiplication, division), with proper handling of decimal points and operator precedence. Score 0 if operations are missing, 5 if basic operations work but have precedence issues, and 10 if all operations work correctly with proper PEMDAS implementation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are advanced calculator features included?",
+      "description": "Evaluate whether the calculator includes scientific functions (sin, cos, tan, log, etc.), memory functions (M+, M-, MR, MC), and conversion capabilities (degrees/radians, different number bases). Deduct 3 points if scientific functions are absent, 3 points if memory functions are missing, and 4 points if no conversions are available. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is input validation and error handling properly implemented?",
+      "description": "Assess how the calculator handles invalid inputs (like division by zero, improper syntax, overflow/underflow). Check for clear error messages and graceful error recovery. Deduct 5 points if the calculator crashes on invalid input, 3 points if errors occur without user notification, and 2 points if error messages are technical rather than user-friendly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is calculation history functionality provided?",
+      "description": "Check if the calculator maintains a history of calculations that users can review, recall, or reuse. Verify if the history persists between sessions using local storage. Deduct 5 points if history functionality is completely absent, 3 points if history exists but can't be interacted with, and 2 points if history doesn't persist between sessions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid consecutive clicks, keyboard and mouse input combinations, or browser-specific issues) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Voice input/output 2. Customizable themes/layouts 3. Formula visualization with graphs). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to perform the same calculation) 2. Function modules unrelated to calculation (e.g., unnecessary widgets or distractions) 3. Fancy effects that affect performance (e.g., excessive animations that slow input response). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating calculation logic/UI/event handling), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (button text size ≥ 14px, proper contrast between numbers and background). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for misaligned buttons or inconsistent spacing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Button press/release feedback ≤ 50ms 2) Visual feedback on operation success/failure 3) Clear state indication (current operation, memory status, etc.). Deduct 5 points for each operation without feedback, 3 points for laggy response when entering multiple digits quickly, and 5 points for confusing state transitions between operations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "easy"
+}

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

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

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

@@ -0,0 +1,68 @@
+{
+  "index": 799,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Pay attention to ensuring that the generated code is executable. I am not a programmer, and I would like to use a large language model to write a simple calculator app. Is this possible?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core calculator functionality fully implemented?",
+      "description": "Review whether the calculator can correctly perform basic arithmetic operations (addition, subtraction, multiplication, division). Check for proper order of operations (PEMDAS), decimal handling, and error prevention for division by zero. Score 0 if calculations are incorrect, 5 if basic operations work but with edge case issues, and 10 if all operations work flawlessly with proper error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the user interface properly implemented?",
+      "description": "Assess the quality of the calculator UI implementation, including proper button layout, input display area, and visual feedback for button presses. Check if the calculator has a clear display for both input and output. Deduct 5 points if the layout is confusing or inconsistent, and 3 points if visual feedback is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the calculator handle user input correctly?",
+      "description": "Evaluate how well the application processes user interactions, including handling consecutive operations, clearing inputs, and managing decimal inputs. Check if the calculator prevents invalid input sequences. Deduct 5 points if it allows impossible mathematical expressions, and 3 points if it doesn't provide input validation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the implementation beginner-friendly?",
+      "description": "Assess if the code is well-commented and structured in a way that a non-programmer can understand and modify it. Check if there are clear explanations of how to run the code and how different parts work. Score 0 if no explanations exist, 5 if basic comments are present but insufficient, and 10 if comprehensive guidance is provided.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, unexpected user behavior, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Memory functions 2. History of calculations 3. Theme switching or customization). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to clear input) 2. Function modules unrelated to a calculator (e.g., unnecessary animations) 3. Overly complex code for simple operations. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/logic layers), code organization, and maintainability. Deduct 5 points if global state is poorly managed; deduct 5 points if the code is difficult to extend or modify; deduct 5 points if there's no clear structure or organization. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast input sequences, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "easy"
+}

package/library/utility_tools-calculation_tools/lottery-number-filter-welfare-lottery-3d.json

@@ -0,0 +1,68 @@
+{
+  "index": 1342,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Can you help me create a lottery number filter for the Welfare Lottery 3D game, similar to the functionality in the \"Number Calculator\" app?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic 3D lottery filtering functionality implemented?",
+      "description": "Check whether the code includes core filtering functions for Welfare Lottery 3D (000-999): digit-specific filters (odd/even, big/small), sum value filters, span value filters, and group/repeat number checks. Score 0 if basic filtering is missing, 5 if only simple filters are implemented, and 10 if comprehensive filtering logic matching professional lottery apps is present.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the implementation include advanced statistical analysis features?",
+      "description": "Evaluate whether the code provides statistical analysis tools such as frequency charts, historical trend analysis, hot/cold number identification, and probability calculations. Deduct 3 points if basic frequency analysis is missing, 5 points if historical data comparison is absent, and 2 points if probability calculations are inaccurate or missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a comprehensive number combination generator with constraints?",
+      "description": "Assess whether the code can generate number combinations based on multiple filter conditions simultaneously, with optimization for performance when generating large sets. Check if the generator can handle complex condition combinations without duplication. Deduct 5 points if the generator doesn't support multiple constraints, 3 points if performance degrades with >1000 combinations, and 2 points if duplicates aren't eliminated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is historical data management and import/export functionality included?",
+      "description": "Check if the code includes functionality to import historical lottery results, save user-defined filters, and export filtered number sets. The system should allow data import from CSV/Excel or direct web scraping from official lottery sites. Deduct 5 points if import/export is missing, 3 points if saved filters cannot be reused, and 2 points if there's no batch operation support. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, unexpected format in imported data, network issues during data fetching, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-based number recommendation 2. Visual pattern recognition in historical data 3. Personalized filtering strategy based on user history). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar filtering functions 2. Function modules unrelated to lottery analysis (e.g., a built-in general calculator) 3. Fancy effects that affect performance (e.g., unnecessary animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating data processing/UI/storage layers), algorithm optimization for lottery calculations, and code maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if algorithm complexity is not optimized for lottery operations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Filter application feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual guidance for filter selection and results. Deduct 5 points for each operation without feedback, 3 points for visual stuttering during number generation, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Calculation Tools",
+  "difficulty": "hard"
+}