@getollie/cli 0.0.1

package/library/svg_generation-svg_images/person-holding-cell-phone-close-up.json

@@ -0,0 +1,68 @@
+{
+  "index": 25,
+  "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 when possible.\nPlease help me implement this SVG image using code. A close up of a person holding a cell phone in their hand.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic SVG structure correctly implemented?",
+      "description": "Check if the code includes proper SVG namespace, viewBox dimensions, and appropriate canvas size. The SVG should have clear width/height attributes or style properties. Deduct 5 points if the SVG namespace is missing, 3 points for inappropriate viewBox dimensions, and 2 points for missing responsive design considerations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the human hand accurately rendered?",
+      "description": "Evaluate the anatomical accuracy of the hand including proper finger proportions, natural finger positioning for holding a phone, and realistic skin contours. Check for correct use of path elements or complex shapes to form the hand. Score 10 points for realistic hand representation with proper shading and detail, 5 points for basic but identifiable hand structure, 0 points if the hand appears anatomically incorrect or unrecognizable. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the cell phone realistically depicted?",
+      "description": "Analyze whether the cell phone has realistic dimensions proportional to the hand, proper screen-to-body ratio, and recognizable modern smartphone features (camera, buttons, etc.). Deduct 3 points if the phone lacks detail, 4 points if proportions are unrealistic, and 3 points if the phone doesn't appear to be properly held. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the interaction points between hand and phone accurately represented?",
+      "description": "Check if the finger positions naturally wrap around the phone with proper contact points and if the grip looks secure and realistic. Examine if z-index and layering are handled correctly where fingers overlap the phone. Score 0 points if fingers appear to pass through the phone, 5 points for basic contact representation, 10 points for realistic gripping with proper pressure points and natural finger positioning. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle different viewports and scaling without distortion. Check if appropriate groups (<g> elements) are used for logical organization of elements and if the code includes appropriate comments for complex paths. Deduct 3 points for each brittle implementation that breaks on resizing, 2 points for poor code organization, and 2 points for lack of documentation on complex elements. The full score is 10 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 image (e.g., 1. Screen content on the phone 2. Subtle animations like finger movements or screen interactions 3. Gradient lighting effects or shadows). 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. Overlapping paths or shapes that add unnecessary complexity 2. Elements unrelated to the hand-holding-phone focus (e.g., excessive background detail) 3. Overly complex filters or effects that impact performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code interferes with the core visual representation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as using reusable components for fingers or phone elements), variable naming conventions, and optimization techniques (like path simplification). Deduct 5 points if inline styles are overused instead of CSS classes; deduct 3 points if there's excessive path data that could be simplified; deduct 2 points if there's no clear organization of SVG elements. 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) Realistic color usage for skin tones and phone materials 2) Proper use of gradients and shadows for depth 3) Attention to detail in proportions and perspective. Deduct 3 points for unrealistic coloring, 3 points for flat appearance without depth, and 4 points for perspective inconsistencies. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the rendering visually refined and detailed?",
+      "description": "Judge the level of visual refinement: 1) Fine details like finger creases, knuckle definition 2) Phone details like buttons, screen bezels, or camera lenses 3) Appropriate use of SVG filters for shadows or highlights. Deduct 3 points for each major area lacking appropriate detail, 2 points for missing subtle visual cues that would enhance realism, and 5 points if the overall image appears too simplistic. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "medium"
+}

package/library/svg_generation-svg_images/person-laptop-gears-close-up.json

@@ -0,0 +1,68 @@
+{
+  "index": 50,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional replies. Make sure the code you generate is executable and can be displayed. Please help me implement the following requirement using SVG code: create a close-up of a person sitting at a laptop with gears.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the SVG rendering properly structured?",
+      "description": "Evaluate whether the SVG includes proper viewport dimensions, viewBox attributes, and organized layer grouping (<g> elements) for different components (person, laptop, gears). Check if proper SVG namespaces are declared. Score 0 if basic SVG structure is missing, 5 if structure exists but lacks organization, 10 if well-organized with proper nesting and namespaces.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the human figure accurately depicted in the close-up view?",
+      "description": "Review whether the person is properly proportioned with clear upper body details (head, torso, arms, hands) and sitting posture. Look for facial features, appropriate clothing details, and natural sitting position. Deduct 3 points if proportions are significantly off, 3 points if the sitting posture looks unnatural, and 4 points if facial/clothing details are completely missing. Full score for anatomically correct rendering that clearly shows a person in close-up view.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the laptop accurately depicted with appropriate details?",
+      "description": "Check if the laptop has realistic proportions, includes essential elements (screen, keyboard, touchpad), and positioned correctly relative to the person. Evaluate screen content visibility and keyboard detail level. Deduct 5 points if the laptop looks 2D or unrealistic, 3 points if essential elements are missing, and 2 points if the positioning relative to the person is implausible. Full score for a detailed, well-proportioned laptop with appropriate perspective.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the gears implemented with mechanical precision and appropriate placement?",
+      "description": "Assess whether gears include teeth details, have appropriate mechanical design (spokes, center holes), and are thoughtfully positioned in the composition (around/behind laptop, near person's head suggesting thought process, etc.). Evaluate if gears look like they could theoretically mesh. Deduct 3 points if gears lack tooth detail, 4 points if gears are randomly placed without purpose, and 3 points if fewer than 3 distinct gears are shown. Full score for precisely drawn gears with meaningful placement.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the SVG code avoids hardcoded magic numbers, uses variables/functions for repeated elements (like multiple gears), and implements reusable patterns. Check if the code would scale to different viewports without breaking. Code with strong robustness should handle different display contexts effectively. Give 10 points for highly reusable code, 5 points for average implementation, and 0 points if the code is brittle with many magic numbers.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the SVG includes surprise features that enhance the experience (e.g., 1. Animation of spinning gears 2. Interactive elements that respond to hover/click 3. Gradient/lighting effects that give depth 4. Clever use of <clipPath> or masks). 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. Duplicate paths or shapes that could be defined once and reused 2. Elements unrelated to the core request (person, laptop, gears) 3. Over-detailed elements that increase complexity without adding value. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code significantly impacts file size or readability.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as defining reusable components with <defs> and <symbol>), proper element IDs/classes, and optimized paths. Deduct 5 points if the code lacks any reuse of repeated elements; deduct 5 points if there's significant path complexity that could be simplified; deduct 5 points if basic SVG optimization techniques aren't applied (like removing unnecessary decimal precision). 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 palette (no more than 3 primary colors with appropriate shades) 2) Proper composition with clear focal point 3) Appropriate use of style attributes for visual hierarchy. Deduct 3 points for each visually jarring element, 5 points for a clashing color scheme, and 5 points for poor composition where the focus is unclear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the visual storytelling effective?",
+      "description": "Judge whether the SVG successfully communicates the intended concept: 1) Clear relationship between person and laptop 2) Gear placement that suggests mental work/productivity 3) Overall composition that conveys focused activity. Deduct 5 points if the relationship between elements is unclear, 3 points if the mood/tone doesn't match a work/creative scenario, and 5 points if the close-up perspective isn't effectively implemented. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "hard"
+}

package/library/svg_generation-svg_images/person-walking-crosswalk.json

@@ -0,0 +1,68 @@
+{
+  "index": 185,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you provide is executable when possible.\nPlease help me implement this SVG image using code: a close up of a person walking across a crosswalk",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic SVG structure properly implemented?",
+      "description": "Check if the SVG element has appropriate viewport dimensions, viewBox settings, and namespace declarations. The SVG should have a reasonable size (e.g., 600x400 or similar) with properly set width/height attributes or responsive sizing. Deduct 5 points if the basic structure is incorrect, 3 points if dimensions are inappropriate for the scene. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the implementation accurately depict a close-up of a person walking across a crosswalk?",
+      "description": "Evaluate if the core visual elements are present: (1) A recognizable human figure with walking pose, (2) Clear white crosswalk stripes on dark road surface, (3) Close-up perspective as requested. Deduct 5 points if any of these key elements is missing, 3 points if they're present but poorly executed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the human figure properly designed and detailed?",
+      "description": "Assess the human figure's anatomical correctness and walking pose authenticity. Check if body proportions are reasonable, with proper limb articulation showing a walking gait. Figure should have appropriate level of detail for a close-up view (facial features, clothing details, etc.). Deduct 4 points for unrealistic proportions, 3 points for static pose instead of walking motion, and 3 points for lack of detail appropriate for a close-up. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the crosswalk properly designed with accurate perspective?",
+      "description": "Verify that the crosswalk stripes follow correct perspective principles, showing appropriate foreshortening based on the viewpoint. White stripes should have consistent spacing and width relative to perspective. Deduct 5 points if perspective is completely wrong, 3 points if the stripes have inconsistent spacing/width, and 2 points if the stripes don't visually read as a crosswalk. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code uses best practices like grouping (<g> elements), reusable definitions (e.g., using <defs>, <symbol>, or <use>), and appropriate element types for different shapes. Check if the code handles potential rendering issues across browsers. Code with strong robustness should be maintainable and efficient, giving 10 points. If the robustness is average, give 5 points, and if code is overly complex or brittle, 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. Animation of walking motion, 2. Interactive elements like hover effects, 3. Responsive design that adjusts to viewport, 4. Creative lighting/shadow effects). 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 SVG elements that could be simplified or grouped, 2. Elements unrelated to the crosswalk scene (e.g., unrelated background objects), 3. Excessive detail that impacts performance (e.g., too many path points or unnecessary filters). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core image is obscured by redundant elements.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review code organization (such as logical grouping of SVG elements), naming conventions, and optimization techniques. Deduct 5 points if elements aren't logically grouped or named; deduct 5 points if the file size is unnecessarily large due to poor optimization; deduct 5 points if accessibility attributes are missing (e.g., role, aria-label, title elements). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the image meet professional design standards?",
+      "description": "Evaluate whether the design follows modern visual principles: 1) Effective use of color (appropriate contrast between road, stripes, and figure), 2) Balanced composition (figure properly placed within frame), 3) Appropriate level of detail for the scene. Deduct 3 points for poor color choices, 5 points for awkward composition, and 5 points for inconsistent level of detail across elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are advanced SVG techniques utilized appropriately?",
+      "description": "Judge whether the implementation uses appropriate SVG capabilities: 1) Proper use of gradients for depth and lighting, 2) Appropriate use of opacity and blending modes, 3) Efficient path construction techniques. Deduct 3 points for missing gradient opportunities, 3 points for flat/unrealistic rendering without advanced features, and 4 points for inefficient path construction. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "medium"
+}

package/library/svg_generation-svg_images/pie-chart-with-large-amount-of-data.json

@@ -0,0 +1,68 @@
+{
+  "index": 195,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable and can be displayed.\nPlease help me implement the following requirement using SVG code: create a close-up view of a pie chart with a large amount of data.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the pie chart correctly implemented with SVG?",
+      "description": "Check if the SVG implementation includes properly calculated arc paths using the SVG 'path' element with correct 'd' attributes for each pie slice. Arc calculations must use Math.sin/cos or SVG arc commands correctly. Score 0 if no pie chart is implemented, 5 if basic pie slices are drawn but have calculation errors, and 10 if all pie slices are mathematically precise.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the close-up view functionality properly implemented?",
+      "description": "Evaluate whether the code includes a mechanism to zoom in or focus on specific sectors of the pie chart. Look for features like hover magnification, separate detailed view, or click-to-zoom functionality. Deduct 5 points if only static magnification is implemented without interaction, and 3 points if the transition between normal and close-up views is abrupt. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "How well does the implementation handle large amounts of data?",
+      "description": "Assess how the code manages pie charts with many data points (20+ slices). Check for techniques like grouping small slices into an 'Other' category, using tooltips for small segments, employing color gradients for related categories, or implementing pagination/filtering. Deduct 5 points if small segments become unreadable, and 3 points if performance noticeably degrades with 50+ data points. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are data labels and legends implemented effectively?",
+      "description": "Check whether the visualization includes proper labels that adjust position based on slice size, with collision detection to prevent overlapping text. For the close-up view, labels should be appropriately scaled and positioned. Verify if a legend is provided for identification of segments. Deduct 5 points if labels overlap significantly, and 3 points if labels are only visible in certain views. 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 missing data, zero values, negative values, extremely small or large segments, etc.) and provide friendly error handling or fallback displays. 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 animations when transitioning to close-up view 2. Smart labeling that adjusts based on segment size 3. Contextual information that appears on interaction). 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 visualization functions (e.g., multiple zoom mechanisms) 2. Function modules unrelated to pie charts (e.g., unnecessary tooltips) 3. Fancy effects that affect performance (e.g., excessive animations or gradients). 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/rendering/interaction layers), reusability of components, and code organization. Deduct 5 points if global state pollution is found or if there's no clear separation of concerns; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern data visualization principles: 1) Harmonious color matching with sufficient contrast between segments 2) Proper visual hierarchy with focus on the close-up area 3) Consistent visual language throughout the chart. Deduct 3 points for each poor color choice that makes segments hard to distinguish, 5 points for cluttered visual elements, and 5 points for inconsistent visual treatment between normal and close-up views. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the interaction smooth and intuitive?",
+      "description": "Judge whether the interaction design conforms to user expectations: 1) Clear visual cues for interactive elements 2) Smooth transitions between normal and close-up views (300-500ms duration) 3) Intuitive controls for navigating the large dataset. Deduct 5 points for each interaction without visual feedback, 3 points for confusing navigation controls, and 5 points for unintuitive zoom/focus mechanics. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "hard"
+}

package/library/svg_generation-svg_images/pie-chart-with-middle-circle.json

@@ -0,0 +1,68 @@
+{
+  "index": 155,
+  "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 can be executed and displayed.\nPlease help me implement the following requirements using code. The requirement is to create a pie chart close-up with a circle in the middle using SVG code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the SVG pie chart structure correctly implemented?",
+      "description": "Review whether the code uses proper SVG path elements to create pie chart segments with accurate mathematical calculations for arc coordinates. Check if the viewBox is properly set and if the pie segments are generated using correct trigonometric functions (sin/cos) for start and end angles. Score 0 if basic pie structure is missing, 5 if segments are present but mathematically incorrect, and 10 if all pie segments are accurately calculated and properly rendered.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the center circle (donut hole) properly implemented?",
+      "description": "Evaluate whether the center circle is correctly positioned and sized to create the donut effect. Check if the inner circle uses appropriate SVG circle element or path mask, and whether the proportions between outer radius and inner radius follow good design principles (typically 0.4-0.6 ratio). Deduct 5 points if the center circle is off-center, 3 points if proportions are visually unbalanced. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the mathematical calculations for arc paths accurate?",
+      "description": "Check whether the SVG path 'd' attributes use correct arc commands (A or a) with proper parameters including radius, x-axis-rotation, large-arc-flag, and sweep-flag. Verify that cumulative angle calculations prevent gaps or overlaps between segments. Deduct 5 points if segments have visible gaps, 3 points if arc parameters are suboptimal but functional, 2 points for minor mathematical inaccuracies. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the data visualization logic properly structured?",
+      "description": "Evaluate whether the code includes proper data input handling, percentage calculations, and segment generation logic. Check if the implementation supports dynamic data updates and maintains data integrity. Deduct 5 points if hardcoded values are used without data abstraction, 3 points if percentage calculations are inaccurate, 2 points if data structure is poorly organized. Give 10 points if fully dynamic and well-structured.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid data inputs, zero values, negative numbers, or sum not equal to 100%) and provide appropriate fallback mechanisms. Code with strong robustness should validate input data and handle edge cases gracefully, giving 10 points. If the robustness is average, give 5 points, and if no error handling exists, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that enhance the visualization?",
+      "description": "Check whether the code includes valuable enhancements (e.g., 1. Interactive hover effects with data labels 2. Smooth animation transitions 3. Legend integration 4. Accessibility features like ARIA labels). Add 3 points for each practical innovative feature implemented (maximum 10 points). Features must be functional and add genuine value to the user experience.",
+      "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 path generation methods) 2. Unnecessary complex animations that don't add value 3. Overly complicated mathematical calculations when simpler solutions exist. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code significantly impacts performance or readability.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review code organization (separation of data, calculation, and rendering logic), naming conventions, and reusability. Deduct 5 points if global variables are overused or functions are not properly separated; deduct 5 points if code duplication rate is high (over 30%); deduct 3 points if variable/function names are unclear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the visual design meet professional standards?",
+      "description": "Evaluate whether the pie chart follows data visualization best practices: 1) Harmonious color palette with sufficient contrast 2) Proper segment spacing and stroke width 3) Readable proportions and clear visual hierarchy 4) Professional typography if labels are included. Deduct 3 points for poor color choices, 5 points for unclear visual proportions, and 5 points for unprofessional overall appearance. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the SVG rendering optimized and accessible?",
+      "description": "Judge whether the SVG code is optimized for performance and accessibility: 1) Minimal DOM elements and efficient path usage 2) Proper semantic structure with titles and descriptions 3) Scalable vector graphics that maintain quality at different sizes 4) Screen reader compatibility. Deduct 5 points for performance issues, 3 points for accessibility violations, and 2 points for poor scalability. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "easy"
+}

package/library/svg_generation-svg_images/play-with-tiles-play-domino-game-visualization.json

@@ -0,0 +1,68 @@
+{
+  "index": 26,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the code you generate is executable and can be displayed.\n\nPlease help me implement the following requirement using SVG code: create a \"Play with Tiles, Play Domino Game\" visualization.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic Domino tile implementation complete?",
+      "description": "Review whether the SVG code accurately represents domino tiles with proper dimensions, dots placement, and dividing line. Each tile should have two sections with dots ranging from 0-6. Score 0 if tiles are not visually identifiable as dominoes, 5 if basic representation is present but with visual imperfections, and 10 if tiles appear professional with proper spacing, proportions, and dot arrangements.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the SVG include a complete set of domino tiles?",
+      "description": "Check if the implementation includes the standard 28 unique domino tiles (from [0,0] to [6,6]). Verify that each tile has a unique visual representation with the correct number of dots on each half. Deduct 5 points if only a subset of tiles is implemented, and 3 points if there are duplicate or incorrect tiles. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the initial game setup and tile arrangement properly implemented?",
+      "description": "Evaluate whether the SVG provides a starting game state with shuffled/randomized tiles and a clear play area. The implementation should include a visible player area and a 'boneyard' (draw pile). Deduct 5 points if tiles aren't shuffled or if the initial state is unclear. Deduct 3 points if the play area isn't visually distinct. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the tile placement and matching logic implemented?",
+      "description": "Check if the SVG implementation includes interactive elements allowing players to place domino tiles according to matching rules (matching numbers connect). The code should validate legal moves and prevent illegal ones. Deduct 5 points if the matching logic is flawed, 3 points if the visual feedback for placement is unclear. 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 tile placements, edge cases in the game rules, browser resize, 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. Animated tile flipping/placement 2. Visual scoring system 3. Multiple game variants like Mexican Train or Block Domino). 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 draw tiles) 2. Function modules unrelated to domino gameplay (e.g., unrelated animations) 3. Fancy effects that affect performance (e.g., excessive filters or gradients that slow rendering). 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 game logic/view components), code organization (grouping related SVG elements), and proper use of SVG features (defs for reusable components, groups for logical organization). Deduct 5 points if global variables pollute the namespace; deduct 5 points if there's significant code duplication; deduct 5 points if SVG best practices aren't followed. 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 visual styling (clear borders, consistent tile design, readable game state). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic tile arrangements. 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/drag feedback delay ≤ 100ms 2) Tile movement/placement animations controlled between 300-500ms 3) Clear visual feedback when placing tiles. Deduct 5 points for each interaction without feedback, 3 points for jerky animations, and 5 points for confusing or hard-to-find interactive elements. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "hard"
+}

package/library/svg_generation-svg_images/pour-from-container-svg-image.json

@@ -0,0 +1,68 @@
+{
+  "index": 147,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable when possible. Please help me implement the following requirements using SVG code: create a scene showing food or drink being poured from a teapot, pitcher, gravy boat, cup, container or bowl.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the SVG container and pouring vessel structure properly implemented?",
+      "description": "Review whether the code accurately implements the main pouring vessel (teapot, pitcher, gravy boat, etc.) using SVG elements with proper geometric structure and proportions. The vessel should have identifiable spout, handle, and body components with realistic proportions. Score 0 if no recognizable vessel is implemented, 5 if basic shapes are present but lack detail, and 10 if the vessel includes all structural elements with proper scaling and positioning.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the liquid pouring animation realistically implemented?",
+      "description": "Check whether the SVG animation accurately depicts liquid flow from the vessel using path animations, gradient effects, or particle systems. The animation should show liquid following realistic physics with proper arc trajectory, varying thickness, and natural flow dynamics. Deduct 5 points if the liquid flow lacks curvature or physics realism, and 3 points if the animation timing feels unnatural. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are proper visual effects and liquid rendering techniques applied?",
+      "description": "Evaluate whether the liquid uses advanced SVG techniques such as gradients, filters, opacity effects, or masking to create realistic liquid appearance. The liquid should have proper color, transparency, and visual depth. Deduct 5 points if basic solid colors are used without gradients, and 3 points if no filter effects enhance the liquid realism. Check for splash effects or droplet details for full marks.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete scene composition and environmental context established?",
+      "description": "Check whether the code includes a complete scene with receiving container, background elements, surface reflections, or environmental context. The scene should show where the liquid is being poured and include supporting visual elements. Deduct 5 points if no receiving container is present, and 3 points if the scene lacks environmental context. Give 10 points if the composition includes multiple contextual elements creating a believable scene.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the SVG code can handle different viewport sizes, browser compatibility issues, and animation edge cases. The code should include proper viewBox settings, fallback mechanisms for unsupported features, and error handling for animation failures. Code with strong robustness should work across different browsers and screen sizes, giving 10 points. If the robustness is average, give 5 points, and if no compatibility considerations are present, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes creative enhancements that elevate the visual experience (e.g., 1. Interactive pour control via mouse movement 2. Steam or aroma effects rising from hot liquids 3. Sound synchronization cues 4. Multiple liquid types with different properties). 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 SVG elements that don't contribute to the scene 2. Overly complex animations that don't enhance realism 3. Excessive decorative elements that distract from the main pouring action. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core pouring visualization is obscured by unnecessary elements.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review SVG code organization, proper use of groups, definitions, and reusable elements. Check for clean structure, meaningful IDs, and efficient use of SVG features. Deduct 5 points if inline styles are mixed with presentation without proper organization; deduct 5 points if no reusable elements or definitions are used when appropriate; deduct 5 points if the code structure is difficult to maintain. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the visual design meet professional illustration standards?",
+      "description": "Evaluate whether the overall design follows professional illustration principles: 1) Coherent color palette that reflects the liquid type 2) Proper lighting and shadow effects 3) Balanced composition with clear focal point on the pouring action 4) Appropriate level of detail without visual clutter. Deduct 3 points for each poorly executed visual element, 5 points for unrealistic color choices, and 5 points for unbalanced composition. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the animation timing smooth and visually appealing?",
+      "description": "Judge whether the animation follows natural motion principles: 1) Smooth frame transitions without jerkiness 2) Appropriate animation duration (2-5 seconds for complete pour cycle) 3) Natural easing functions that mimic real liquid physics 4) Seamless loop capability if designed as repeating animation. Deduct 5 points for choppy animations, 3 points for unrealistic timing, and 5 points for jarring transition effects. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "hard"
+}

package/library/svg_generation-svg_images/raincoat-water-resistant-clothing-for-weather.json

@@ -0,0 +1,68 @@
+{
+  "index": 183,
+  "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 can be executed and displayed. Please help me implement this SVG image using code. The raincoat is water-resistant clothing for the weather.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the SVG raincoat structure properly implemented?",
+      "description": "Check whether the code properly implements the basic structure of a raincoat (hood, body, sleeves, buttons/zipper). Score 0 if the basic raincoat outline is missing, 5 if only a basic outline is present without details, and 10 if the SVG includes a complete and recognizable raincoat structure with appropriate proportions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the SVG properly represent the water-resistant nature of the raincoat?",
+      "description": "Evaluate whether the code includes visual elements that communicate water resistance (such as water droplets rolling off, glossy/waterproof texture, or appropriate material representation). Deduct 5 points if no water-resistant characteristics are represented and 3 points if the representation is minimal. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the SVG code optimized and standards-compliant?",
+      "description": "Review whether the SVG uses appropriate elements (path, rect, circle) efficiently, includes proper viewBox attributes, and follows SVG best practices. Check for unnecessary nested groups, redundant paths that could be combined, or inefficient use of transforms. Deduct 3 points for each significant optimization issue found. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are weather elements incorporated to contextualize the raincoat?",
+      "description": "Assess whether the SVG includes contextual weather elements (rain droplets, clouds, puddles) that help communicate the purpose of the raincoat. Score 0 if no weather context is provided, 5 if minimal context is shown, and 10 if the raincoat is clearly placed in a weather-related context with appropriate visual elements.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle different viewport sizes without breaking, includes appropriate fallbacks for older browsers, and properly manages aspect ratios. Code with strong robustness should scale appropriately on different devices and degrade gracefully. Give 10 points if fully responsive with fallbacks, 5 points if partially responsive, and 0 points if the SVG breaks on resizing.",
+      "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. Animated rain effects 2. Interactive elements like toggleable hood or buttons 3. Color-changing options to show different raincoat styles). 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 SVG elements that could be simplified 2. Elements unrelated to the raincoat or weather context 3. Overly complex effects that make the SVG unnecessarily large or slow to render. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core representation is obscured by redundant elements.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review code organization (such as meaningful IDs/classes, grouped related elements), reusability of components, and documentation. Deduct 5 points if SVG elements are poorly organized; deduct 5 points if there's excessive repetition of values that could be defined once; deduct 5 points if the code lacks comments explaining complex parts. 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 (appropriate colors for a raincoat and weather elements) 2) Balanced composition (proper visual weight and negative space) 3) Attention to detail (texture, shadows, highlights where appropriate). Deduct 3 points for each visual harmony issue, 5 points for inappropriate color choices, and 5 points for poor detail rendering. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether any animations or interactive elements (if implemented) conform to natural movement: 1) Smooth transitions between states 2) Animation timing that feels natural (e.g., rain falling at realistic speed) 3) Logical interaction points if the SVG is interactive. Deduct 5 points for jarring animations, 3 points for unrealistic movement patterns, and 5 points for confusing interactive elements. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "medium"
+}