@getollie/cli 0.0.1

package/library/utility_tools-automation/ai-code-generation-management-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 815,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable whenever possible. Implement a system that, after receiving all system functional requirements submitted by users, automatically calls AI to generate code, module by module, and then compiles them into a complete, runnable system code package. Keep it simple and easy to implement. I'm providing you with a simplified approach: first, implement only the ability to generate a simple management system, then use templates to standardize user input, simplifying the understanding of the input.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the requirements parsing mechanism fully implemented?",
+      "description": "Evaluate whether the system effectively parses user-submitted requirements. Check for structured input validation, natural language processing capabilities, and domain-specific terminology recognition. Score 0 if there's no parsing mechanism, 5 if basic template-based requirement parsing exists, and 10 if advanced NLP techniques with error correction are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the code generation system properly integrated with AI models?",
+      "description": "Verify the integration with AI code generation services (like OpenAI API, Anthropic API, etc.). Check for proper API authentication, error handling for failed calls, rate limiting mechanisms, and response validation. Deduct 5 points if only a single AI provider is supported with no fallback, and 3 points if the system doesn't handle context limitations effectively. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the module-by-module generation approach implemented properly?",
+      "description": "Assess the system's ability to break down requirements into logical modules, generate code for each module independently, and maintain consistency across generated components. Check for dependency management between modules. Deduct 5 points if module interfaces are poorly defined, and 3 points if there's no mechanism to ensure consistency across modules. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the code compilation and packaging mechanism functional?",
+      "description": "Evaluate whether the system can effectively compile and package the generated code into a runnable system. Check for appropriate build tools integration, dependency management, and output validation. Deduct 5 points if the system can't handle compilation errors, and 3 points if it lacks appropriate packaging for different environments (development/production). 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 malformed requirements, AI service outages, compilation failures, 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 requirement refinement 2. Visual preview of generated system components 3. Automatic code quality assessment). 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 requirement parsing engines) 2. Function modules unrelated to code generation (e.g., built-in entertainment features) 3. Overly complex features that don't improve the core functionality. 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 requirement processing/code generation/compilation layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual feedback during long-running operations like code generation. Deduct 5 points for each operation without feedback, 3 points for unclear progress indicators during generation, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/allocate-nameplate-positions-personnel-list.json

@@ -0,0 +1,68 @@
+{
+  "index": 803,
+  "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. To organize a meeting, you need to determine the placement of nameplates based on the personnel list order. Please create a small program or tool that automatically allocates nameplate positions according to the personnel list order, so that when the personnel order changes, the nameplate placement positions change accordingly.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the nameplate allocation logic fully implemented?",
+      "description": "Review whether the code accurately implements the core nameplate allocation algorithm that maps personnel list order to physical placement positions. Check if the mapping is bijective (one-to-one correspondence), maintains the original ordering logic, and handles edge cases like empty lists. Score 0 if the core allocation logic is missing, 5 if only basic mapping is implemented without considering spatial constraints, and 10 if the implementation includes optimization for readability and accessibility in physical space.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the implementation handle dynamic personnel changes?",
+      "description": "Evaluate how the system responds when the personnel list changes (additions, removals, or reordering). Check if the code includes re-allocation functionality that updates nameplate positions accordingly without manual intervention. Deduct 5 points if the system requires a complete restart for changes, 3 points if it handles additions but not removals or reordering. The full score is 10 points if it provides real-time updates with animation transitions between states.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the visualization of nameplates clearly implemented?",
+      "description": "Check whether the visualization code (HTML/CSS/SVG) properly displays the nameplates with clear text, appropriate sizing, and distinguishable boundaries. Verify if the visualization accounts for different name lengths and provides adequate spacing between nameplates. Deduct 5 points if text overflows or becomes illegible with longer names, 3 points if the nameplates lack visual distinctiveness. The full score is 10 points for a responsive, accessible, and visually pleasing implementation.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a user-friendly interface for managing the personnel list?",
+      "description": "Assess if the implementation includes an intuitive interface for adding, removing, and reordering personnel. Check for drag-and-drop functionality, input validation, and immediate visual feedback. Deduct 5 points if the interface requires code editing to update the list, 3 points if it has a form but no visual confirmation of changes. Give 10 points if the interface includes batch operations and preserves state between sessions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as duplicate names, special characters in names, extremely long names, or empty fields) 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. Template-based nameplate designs 2. Automatic optimized layout suggestions based on room dimensions 3. Print/export functionality for physical production). 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 reorder the same list) 2. Function modules unrelated to nameplate allocation (e.g., a built-in calendar system) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the interface). 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/view/controller layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

package/library/utility_tools-automation/analyze-c-program-time-complexity-big-o.json

@@ -0,0 +1,68 @@
+{
+  "index": 1787,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable whenever possible. Please help me create a small program that can analyze the asymptotic time complexity of input C language program fragments (note that these are incomplete program fragments) and output the results in Big O notation. Please generate this as an HTML program.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the C code parsing functionality implemented correctly?",
+      "description": "Evaluate whether the code accurately parses and identifies common C language constructs that affect time complexity (loops, recursive calls, nested structures). Check if it handles different loop types (for, while, do-while), can identify loop boundaries and increment patterns, and recognizes function calls. Score 0 if parsing is absent, 5 if only basic structures are recognized, and 10 if comprehensive parsing of complex C fragments is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the time complexity analysis algorithm implemented properly?",
+      "description": "Assess the correctness of the time complexity calculation logic. Check if it properly identifies and combines nested loops (O(n²)), logarithmic patterns (O(log n)), recursive complexity patterns, and handles multiple code paths. The analysis should correctly determine constants vs. variable factors. Deduct 5 points if it only handles simple loops, and 3 points if it misidentifies recursive complexity. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the complexity detection comprehensive across various algorithm patterns?",
+      "description": "Check whether the analyzer can recognize common algorithm patterns and their complexities: divide-and-conquer (O(n log n)), binary search (O(log n)), polynomial time algorithms (O(n^k)), and exponential complexities (O(2^n)). Must correctly identify amortized complexity cases and combine multiple complexity sources. Deduct 5 points if complex algorithm patterns are misidentified, and 3 points if edge cases like O(n log n) are missed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the user interface and visualization of analysis results effective?",
+      "description": "Evaluate the clarity and intuitiveness of how analysis results are presented. The interface should show the original code alongside the complexity analysis, highlight critical code sections affecting complexity, and provide meaningful explanations. The Big O notation should be properly formatted and visualized. Deduct 5 points if visualization is minimal, and 3 points if complex results lack clear explanation. 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 incomplete code fragments, syntax errors, infinite loops, uncommon C syntax, or malformed input) 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 complexity growth visualization 2. Comparative analysis of multiple code fragments 3. Suggestions for optimization with examples). 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 analysis functions 2. Function modules unrelated to complexity analysis (e.g., a full C compiler) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow down analysis). 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 parsing/analysis/visualization layers), clear algorithm documentation, and maintainable structure. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments explaining complex analysis logic. 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 for code highlighting and complexity indicators 2) Proper layout spacing between code sections and analysis results 3) Professional font system with monospace for code and readable fonts for explanations. 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) Analysis feedback delay ≤ 500ms for typical code fragments 2) Smooth transitions when showing detailed explanations 3) Clear visual indications during analysis process. Deduct 5 points for operations without feedback, 3 points for laggy response on complex inputs, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

package/library/utility_tools-automation/automated-css-formatter-with-comments.json

@@ -0,0 +1,68 @@
+{
+  "index": 699,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable whenever possible. Implement an automated CSS code formatting tool where users can paste messy or unformatted CSS code into a text box, and the tool will automatically format the code while preserving comments to improve readability.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the CSS parsing and formatting core functionality fully implemented?",
+      "description": "Evaluate whether the code can correctly parse various CSS structures (including nested rules, media queries, keyframes, vendor prefixes, etc.) and format them consistently. Score 0 if the parser fails on complex CSS, 5 if it handles basic selectors and properties but struggles with advanced features, and 10 if it successfully handles all CSS3 specifications including complex selectors and at-rules.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the code preserve and properly format comments?",
+      "description": "Check if the tool correctly identifies and preserves all types of CSS comments (inline, block, license headers) during formatting without modifying their content or breaking their association with relevant CSS rules. Deduct 5 points if some comments are lost or misplaced, 3 points if comment positioning is inconsistent, and 2 points if the original formatting within comments is altered unnecessarily. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are customizable formatting options provided to the user?",
+      "description": "Review whether the tool offers configuration options for formatting preferences (e.g., indentation size, tabs vs spaces, single vs multi-line rules, property sorting, etc.). Score 0 if no options are available, 5 if only basic options exist, and 10 if comprehensive configuration is supported with sensible defaults and visual previews of formatting changes.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper error handling for malformed CSS input?",
+      "description": "Assess how the tool handles invalid CSS input - whether it provides helpful error messages, highlights problematic lines, suggests fixes, or attempts partial formatting while preserving the original input. Deduct 3 points if error locations are not indicated, 4 points if cryptic error messages are shown, and 5 points if the tool crashes on malformed input without graceful recovery. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle edge cases (extremely long files, unusual whitespace patterns, Unicode characters in selectors, escaped sequences, etc.) and provide appropriate responses. 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 edge cases 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. Syntax highlighting in the formatted output 2. Visual diff between original and formatted code 3. CSS property sorting/grouping options 4. Minification toggle alongside formatting). 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 parsing logic that could be unified 2. Unnecessary processing steps unrelated to CSS formatting 3. Performance-heavy features that slow down the core formatting functionality. 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 (separating lexer/parser/formatter components), test coverage for various CSS structures, and maintainability. Deduct 5 points if global state causes side effects; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no unit tests for core formatting functions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the UI follows modern design principles: 1) Clear input/output areas with sufficient contrast 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system with monospace for code display (minimum 14px size). Deduct 3 points for each cramped interface element, 5 points for poor contrast making code hard to read, and 5 points for chaotic layout with inconsistent spacing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the tool provides good user experience: 1) Formatting response time under 500ms for typical files 2) Visual feedback during processing of large files 3) Keyboard shortcuts for common actions (format, copy, clear). Deduct 5 points for noticeable UI freezing during formatting, 3 points for lack of visual processing indicators, and 5 points if formatting results aren't easily selectable/copyable. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "easy"
+}

package/library/utility_tools-automation/automated-unmanned-printing-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 1029,
+  "question": "You are a coding expert, please use your professional knowledge to generate accurate and professional responses. Take care to ensure the code you generate is executable. I specialize in automated printing. Please help me develop a simple yet sophisticated unmanned printing system.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core printing functionality properly implemented?",
+      "description": "Review whether the code accurately implements essential printing functions: queue management, document processing pipeline, and printer communication protocols (such as IPP, CUPS, or direct driver integration). Score 0 if core printing logic is missing, 5 if basic printing is implemented without proper error handling, and 10 if the system includes comprehensive printing capabilities with status monitoring.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the automated workflow management system complete?",
+      "description": "Check if the code implements a complete workflow from file submission to final printing, including file validation, preprocessing (format conversion if needed), print job scheduling, and post-processing notifications. Deduct 3 points if file validation is inadequate, 3 points if job prioritization is missing, and 4 points if there's no completion notification system. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the user interface for self-service printing intuitive and accessible?",
+      "description": "Evaluate whether the interface provides clear step-by-step guidance for users, supports multiple file upload methods, offers preview functionality, and includes payment processing if required. Deduct 3 points for confusing navigation, 3 points for limited file format support, and 4 points if the preview functionality is missing or inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a comprehensive error handling and recovery system?",
+      "description": "Assess whether the code includes robust error detection for common printing issues (paper jams, low toner, connectivity problems), provides clear user notifications, and implements recovery procedures. Deduct 3 points if error detection is limited, 3 points if notifications are unclear, and 4 points if recovery procedures are inadequate or missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle edge cases such as unexpected file formats, large print jobs, concurrent user requests, power outages, and network interruptions. Code with strong robustness should gracefully handle these scenarios with appropriate logging and recovery mechanisms, giving 10 points. If the robustness is average, give 5 points, and if no exception handling exists, 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. Mobile app integration with QR code submission 2. AI-based document optimization for print quality 3. Smart resource estimation before printing 4. Print job analytics dashboard). 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 file processing pipelines) 2. Function modules unrelated to printing (e.g., unnecessary multimedia features) 3. Fancy effects that affect system performance (e.g., excessive animations in the interface). 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/business logic/printer communication layers), unit test coverage, and deployment 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 configuration management is poor with hardcoded values. 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) Response time for user actions ≤ 100ms 2) Clear progress indicators for printing operations 3) Intuitive status updates and feedback. Deduct 5 points for each operation without feedback, 3 points for confusing state transitions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/avalonia-dynamic-viewmodel-reflection-code-generation.json

@@ -0,0 +1,68 @@
+{
+  "index": 1353,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the generated code is executable for demonstration. Generate Avalonia axaml page code, control code, and view models dynamically based on table names, table fields, field classes, field control types, field visibility, field default values, etc. Use reflection to dynamically create properties and add them to the view model at runtime.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the dynamic AXAML generation system fully implemented?",
+      "description": "Review whether the code correctly generates Avalonia AXAML based on table metadata. Check if it handles different layout types (Grid, StackPanel, DockPanel), properly sets column definitions and row definitions, and correctly positions controls. Score 0 if dynamic AXAML generation is not implemented, 5 if basic generation works but with layout issues, and 10 if the generation system is complete with proper nesting and responsive layout.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all control types properly supported and instantiated?",
+      "description": "Verify that the code can dynamically create and configure different Avalonia controls (TextBox, ComboBox, DatePicker, CheckBox, etc.) based on field types. Check if control-specific properties and behaviors are correctly set. Deduct 2 points for each unsupported common control type, and 5 points if custom control templates are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the reflection-based property system correctly implemented?",
+      "description": "Evaluate whether the code uses reflection to dynamically create properties at runtime and add them to view models. Check for proper implementation of INotifyPropertyChanged, property change notifications, and type-safe property access. Deduct 5 points if dynamic property creation is not implemented, 3 points if property change notifications are missing, and 2 points if type conversion is not handled properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are data binding and validation mechanisms properly implemented?",
+      "description": "Check if the code implements two-way data binding between the dynamically generated UI and view model properties. Verify that input validation, error reporting, and error visualization work correctly. Deduct 5 points if data binding is one-way only, 3 points if validation is missing, and 5 points if there's no visual feedback for validation errors. 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 metadata, invalid field types, null references, 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. Live preview of generated UI 2. Metadata editor with real-time AXAML updates 3. Theme switching for generated controls). 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 reflection helper methods doing the same thing) 2. Function modules unrelated to dynamic UI generation 3. Overly complex code that could be simplified. 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 metadata handling/code generation/view model creation), unit test coverage, and proper error handling. Deduct 5 points if there's tight coupling between components; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no exception handling strategy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the generated UI meet professional design standards?",
+      "description": "Evaluate whether the generated UI follows modern design principles: 1) Proper control spacing and margins 2) Consistent form layout with aligned labels and inputs 3) Professional visual hierarchy of elements. Deduct 3 points for poor alignment of form elements, 5 points for inconsistent spacing between controls, and 5 points for poor visual hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the dynamic UI updates conform to good UX practices: 1) Fast property updates without UI freezing 2) Smooth transitions when showing/hiding controls 3) Responsive feedback during long operations. Deduct 5 points for UI freezes during updates, 3 points for jarring control visibility changes, and 5 points for lack of loading indicators during long operations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/bi-weekly-plan-random-selector-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 1566,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration. Help me create a bi-weekly plan random selection tool using Python with buttons that randomly selects from the following items: Wood Carving, I Ching, Seal Engraving, Shoujinti Calligraphy, Butterfly Knife, Sketching, Small Liuren Divination, Chess, HTML Front-end Development, Piano, Sign Language, Novel, Comic Strip, Traditional Chinese Medicine, 3D Printing, Website Development, 3D Modeling, Braille. The buttons should be light gray, the page background should be black, and the text should be white. I have a website and need clear code that I can integrate into my webpage.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core random selection functionality properly implemented?",
+      "description": "Evaluate whether the Python code correctly implements a random selection algorithm that evenly distributes the probability across all items. Check if the selection is truly random (using appropriate libraries like random.choice) and if it avoids repetition in consecutive selections. Score 0 if randomization is missing, 5 if basic randomization exists but lacks proper distribution, and 10 if it includes both even distribution and protection against repeated consecutive selections.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the bi-weekly plan concept properly reflected in the implementation?",
+      "description": "Check if the tool addresses the bi-weekly nature of the planning. Does it track selection history? Does it have date tracking or scheduling capabilities? Does it prevent the same activity from being selected twice in the same bi-weekly period? Deduct 3 points if it lacks date tracking, 3 points if it doesn't maintain history, and 4 points if it allows duplicate selections within the same period. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the UI implementation complete with the specified design requirements?",
+      "description": "Verify that the interface strictly follows the specified color scheme (light gray buttons, black background, white text). Check if the buttons are properly styled, accessible, and responsive. Deduct 3 points if colors don't match specifications, 3 points if buttons are poorly styled, and 4 points if the interface is not responsive to different screen sizes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the code structured for easy website integration?",
+      "description": "Evaluate whether the provided code can be easily integrated into an existing website. Check for modular design, self-contained components, minimal dependencies, and clear documentation on how to integrate. Deduct 3 points if external dependencies aren't clearly specified, 3 points if integration instructions are missing, and 4 points if the code heavily modifies existing page structure. 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 browser inconsistencies, failed random selections, empty item lists, 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. Animation effects when selecting an item 2. Option to exclude certain activities 3. History tracking with visual representation). 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 random selection methods) 2. Function modules unrelated to the random selection tool (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating logic/view layers), code reusability, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code is not well-documented with comments. 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 (proper contrast between black background, white text, and light gray buttons) 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 poor contrast or readability, 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 feedback when an item is selected. Deduct 5 points for each operation without feedback, 3 points for sluggish response times, and 5 points for confusing or unclear selection indication. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "easy"
+}

package/library/utility_tools-automation/build-project-react-vite-typescript.json

@@ -0,0 +1,68 @@
+{
+  "index": 816,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable. Build a project using React 18.3.1 version and Vite with TypeScript.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the React 18.3.1 project with Vite and TypeScript correctly initialized?",
+      "description": "Check if the project setup includes proper configuration files (package.json with correct dependencies, tsconfig.json, vite.config.ts). Verify React 18.3.1 is specified correctly and Vite is configured for TypeScript. Score 0 if basic setup is missing, 5 if some configurations are incorrect or incomplete, 10 if fully and properly configured.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are React 18.3.1 specific features utilized appropriately?",
+      "description": "Evaluate whether the code leverages React 18.3.1 specific features like useOptimistic, useFormStatus, use hook, or other new APIs. Deduct 5 points if no React 18.3.1 features are used, 3 points if they're used inappropriately. Give 10 points if features are implemented correctly with proper error boundaries and fallbacks.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is TypeScript properly integrated and utilized throughout the codebase?",
+      "description": "Analyze the TypeScript implementation including proper type definitions, interfaces, generics, and type guards. Check for strict mode usage and proper typing of props, state, and function parameters/returns. Deduct 5 points for any use of 'any' type without justification, 3 points for missing type definitions. Full score requires comprehensive typing with no type errors.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the project follow proper Vite configuration and optimization?",
+      "description": "Check for correct Vite configuration including environment variables, build optimizations, and proper plugin setup. Verify if code-splitting is implemented, assets are optimized, and development features like HMR are working. Deduct 5 points if build process is not optimized, 3 points if environment configurations are missing. 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 network failures, unexpected input, component errors) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should use ErrorBoundary components, implement proper form validation, and handle async operations correctly, 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. Custom hooks for complex state management 2. Animated transitions between components 3. Performance optimizations like memoization). 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 re-renders or inefficient component structures 2. Unused imports, components, or code 3. Excessive dependencies that could be replaced with built-in functionality. Deduct 3 points for each redundancy found, and directly deduct 10 points if core functionality is compromised by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review folder structure, component organization, code reusability, and build pipeline. Check for proper separation of concerns, custom hook abstractions, and testable code. Deduct 5 points if component organization is chaotic; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no tests. 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 jank during animations, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "easy"
+}