@getollie/cli 0.0.5 → 0.2.1

package/library/svg_generation-svg_images/women-red-lipstick-beauty-accessory.json

@@ -1,68 +0,0 @@
-{
-  "index": 159,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration purposes.\nPlease help me implement this SVG image using code. Women use red lipstick as a beauty accessory.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core SVG lipstick element properly rendered?",
-      "description": "Evaluate whether the lipstick shape is accurately rendered with appropriate SVG elements (path, rect, etc.). The lipstick should include both the tube body and the colored tip part. Check if proper dimensions are used for proportionality, and if the overall shape resembles a realistic lipstick. Score 0 if no lipstick is visible, 5 if only a basic shape is implemented, and 10 if the lipstick has detailed components and realistic proportions.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the coloring of the lipstick accurate and aesthetically pleasing?",
-      "description": "Review the color choices used for the lipstick. The tip should be in an appropriate shade of red that looks like actual lipstick. The tube/case should have appropriate contrasting color (gold, silver, black, etc.). Points are deducted for unrealistic colors (e.g., blue lipstick tip), poor color matching between components, or lack of shading that makes the lipstick look flat. Score 0 if colors are completely inappropriate, 5 for basic coloring, and 10 for realistic lipstick coloring with appropriate shading.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are proper SVG techniques utilized for visual enhancement?",
-      "description": "Check whether the implementation uses appropriate SVG techniques such as gradients, shadows, highlights, or patterns to enhance the realism of the lipstick. Evaluate use of techniques like linear/radial gradients for glossy effects, filter effects for shadows, or path manipulations for precise shapes. Deduct 5 points if no enhancement techniques are used, and 3 points if techniques are used but poorly implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the lipstick positioned effectively with appropriate context elements?",
-      "description": "Assess whether the lipstick is presented with appropriate context (e.g., slight tilt to show usage angle, potentially on a surface or with beauty accessories). Check if the positioning creates a coherent image that communicates the lipstick as a beauty accessory. Deduct 5 points if the lipstick is floating without context, and 3 points if positioning is awkward or unrealistic. Full points for thoughtful positioning that enhances the presentation.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common display issues (browser compatibility, scaling/responsive display, etc.) and provides fallback options or appropriate viewBox settings. Code with strong robustness should be able to render consistently across modern browsers and screen sizes, giving 10 points. If the robustness is average, give 5 points, and if no considerations for robustness are made, 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 like lipstick application or cap removal 2. Interactive elements that respond to user input 3. Creative presentation elements beyond basic requirements). 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 or groups that serve no purpose 2. Excessive detail that impacts performance without visual benefit 3. Unnecessary animations or effects that distract from the main subject. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core subject (lipstick) 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), proper naming of groups/elements, and efficient use of SVG features. Deduct 5 points if elements are not properly grouped or named; deduct 5 points if the code contains duplicated patterns that could be optimized; deduct 5 points if the implementation unnecessarily increases file size through inefficient techniques. 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 (realistic and aesthetically pleasing) 2) Proper proportions and visual balance 3) Professional finish with attention to detail. Deduct 3 points for each unrealistic proportion, 5 points for jarring color combinations, and 5 points for poor visual balance. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the implementation complete and suitable for the described purpose?",
-      "description": "Judge whether the final SVG effectively represents a lipstick as a beauty accessory: 1) Clear recognition as lipstick without explanation 2) Visual quality that communicates 'beauty product' rather than just an object 3) Overall impression that aligns with cosmetic industry standards. Deduct 5 points if the lipstick is unrecognizable without context, 3 points if it lacks refinement expected of beauty products, and 5 points if it fails to convey the accessory aspect. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "SVG Generation-SVG Images",
-  "difficulty": "hard"
-}

package/library/svg_generation-svg_posters/customizable-recruitment-poster-vue-svg.json

@@ -1,68 +0,0 @@
-{
-  "index": 321,
-  "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 whenever possible. I am a frontend developer, and I need to develop a customizable recruitment poster application where users can design their own poster templates and export them as vector files. How can this be implemented using Vue and SVG?",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core SVG poster generation system fully implemented?",
-      "description": "Check whether the code effectively implements an SVG-based poster generation system that allows for dynamic customization. Score 0 if there's no SVG generation code, 5 if basic SVG elements are rendered without proper customization, and 10 if the system provides a comprehensive API for creating, modifying, and styling SVG elements in the poster context.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the Vue implementation provide a robust component architecture for the editor?",
-      "description": "Evaluate the Vue component architecture. Check if components are properly segregated (e.g., canvas component, toolbar component, property panel component), if they use proper prop validation, emit proper events, and if the state management is appropriate for this use case (Vuex/Pinia for complex state, component state for local concerns). Deduct 3 points for monolithic components, 3 points for prop-drilling beyond 2 levels, and 4 points if reactive data isn't properly utilized.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the template management system properly implemented?",
-      "description": "Verify if users can save, load, and manage poster templates. Check if templates are serialized in a proper format (JSON), if the system handles template versioning, and if predefined templates are available as starting points. Deduct 5 points if template saving is not implemented, 3 points if there's no way to categorize templates, and 2 points if template previews aren't generated.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the vector file export functionality correctly implemented?",
-      "description": "Examine if the system can export designs in vector formats (SVG, AI, EPS, or PDF). Check if the export preserves all visual elements, layers, and effects. Verify if text remains editable in the exported files. Deduct 5 points if only raster export is available, 5 points if vector export loses fidelity, and 5 points if user isn't given export options (size, format, quality).",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid SVG data, failed exports, browser compatibility issues) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time collaborative editing 2. AI-assisted design recommendations 3. Advanced SVG filters and effects 4. Integration with design asset libraries). 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 edit the same property) 2. Function modules unrelated to poster design (e.g., a built-in image editor when simple crop/resize would suffice) 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 editor logic/view/data 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": "SVG Generation-SVG Posters",
-  "difficulty": "medium"
-}

package/library/utility_tools-automation/ai-automatic-webpage-creation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1596,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code when possible. How can AI be used to automatically create webpages?",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Does the solution provide a comprehensive explanation of AI webpage generation approaches?",
-      "description": "Evaluate whether the response thoroughly explains different AI approaches for webpage generation (e.g., GPT models, GAN-based solutions, template-based AI systems, automated layout engines). Score 0 if only a single approach is mentioned, 5 if multiple approaches are covered but lack technical depth, and 10 if the explanation includes multiple well-explained methodologies with their respective strengths and limitations.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is there functioning code for an AI webpage generator implementation?",
-      "description": "Check if the code provided can actually generate HTML/CSS webpages. The solution should include either: 1) integration with AI APIs (like OpenAI), 2) a local ML model implementation, or 3) a hybrid approach. Test if the code executes without errors and produces valid HTML output. Deduct 5 points if the code requires significant modifications to run, deduct all 10 points if the code is fundamentally flawed or non-executable.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the solution handle user requirements and content processing?",
-      "description": "Assess if the implementation includes parsing and understanding user requirements (e.g., converting natural language descriptions to webpage specifications). The code should extract key elements like layout preferences, color schemes, and content structure from user inputs. Deduct 5 points if the solution lacks requirement parsing mechanisms, deduct 3 points if it fails to handle ambiguous user inputs. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a mechanism for customization and refinement of AI-generated webpages?",
-      "description": "Evaluate whether the solution includes tools for users to refine the AI-generated content (such as feedback loops, parameter adjustments, or iterative generation). Check if the implementation allows for specification of style guides or brand requirements. Deduct 5 points if refinement is manual only, deduct 3 points if the customization options are too limited. 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 user inputs, API failures, resource limitations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time preview of generated pages 2. Multi-modal input processing (text, images, voice) 3. Accessibility compliance checking for generated pages). 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 HTML generators with overlapping capabilities) 2. Function modules unrelated to webpage generation (e.g., unnecessary analytics tools) 3. Resource-intensive features that affect performance (e.g., excessive API calls or computations). 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 AI logic/webpage rendering/user interface 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 solution consider webpage quality and standards compliance?",
-      "description": "Evaluate whether the generated webpages follow modern web standards: 1) Valid HTML/CSS that passes W3C validation 2) Responsive design principles for multi-device support 3) Semantic HTML structure for accessibility. Deduct 3 points for non-validating code, 5 points for non-responsive layouts, and 5 points for poor semantic structure. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Does the solution address performance and scalability concerns?",
-      "description": "Judge whether the implementation considers performance optimization: 1) Generation time for pages ≤ 30 seconds 2) Reasonable resource consumption 3) Capability to handle multiple concurrent requests. Deduct 5 points for slow generation times, 3 points for excessive resource usage, and 5 points for lack of concurrent request handling. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "medium"
-}

package/library/utility_tools-automation/ai-automatically-write-website-code.json

@@ -1,68 +0,0 @@
-{
-  "index": 1276,
-  "question": "You are a code expert. Please utilize your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. How can I make AI automatically write website code for me?",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is there a clear explanation of AI code generation concepts and approaches?",
-      "description": "Check whether the response explains the fundamental concepts of AI code generation, including different approaches (prompt engineering, model fine-tuning, using specialized AI coding assistants). Deduct 5 points if only a single approach is explained, 7 points if the explanation lacks technical depth. Full score: 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are practical tools and platforms for AI website code generation presented?",
-      "description": "Evaluate the comprehensiveness of the AI code generation tool recommendations (e.g., GPT-4, GitHub Copilot, Amazon CodeWhisperer, Microsoft Power Pages). Deduct 3 points for each major platform category missing (code completion tools, no-code builders, specialized code generators). Give 10 points for a comprehensive list with pros/cons of each tool.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a detailed walkthrough for using at least one AI code generation system?",
-      "description": "Review whether the response provides step-by-step instructions for at least one AI code generation approach, including setup, prompt design, and output handling. Deduct 5 points if the instructions are too vague to follow, 3 points if they lack screenshots/examples. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are there sample prompts or templates specifically designed for website code generation?",
-      "description": "Check if the response includes effective prompt engineering techniques or templates specifically for website development tasks (e.g., layout creation, component design, API integration). Deduct 3 points for generic prompts without web-specific guidance, 5 points if fewer than 3 usable templates are provided. Full score: 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether any sample code provided handles common edge cases (responsive design, accessibility concerns, cross-browser compatibility, input validation, etc.) and follows best practices. Code with strong robustness should 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 response includes surprise features that enhance the AI code generation experience (e.g., 1. Version control integration 2. Automatic documentation generation 3. Performance optimization suggestions). Add 3 points for each practical innovative feature mentioned (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant explanation of similar AI tools 2. Unnecessary technical details unrelated to website generation 3. Overly complex approaches that complicate the process. Deduct 3 points for each redundancy found, and directly deduct 10 points if core information is obscured by redundant content.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the response have engineering quality?",
-      "description": "Review whether the methodology suggested follows software engineering best practices (separation of concerns, modular design, testing strategies, iterative improvement). Deduct 5 points if the approach encourages monolithic code generation; deduct 5 points if no testing/validation strategy is mentioned; deduct 5 points if the process isn't iterative. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the guidance consider UI/UX design principles?",
-      "description": "Evaluate whether the AI code generation approach incorporates modern design principles: 1) Responsive design 2) Accessibility standards 3) Visual hierarchy and user flow. Deduct 3 points for each design principle category neglected, 5 points if there's no mention of testing the generated UI with users, and 5 points if performance considerations are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is there practical advice on limitations and human oversight?",
-      "description": "Judge whether the response realistically addresses the limitations of AI code generation and provides guidance on necessary human oversight: 1) Security review needs 2) Performance optimization 3) Business logic validation. Deduct 5 points for overpromising AI capabilities, 3 points for not addressing technical debt concerns, and 5 points for failing to mention testing requirements. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Utility Tools-Automation",
-  "difficulty": "easy"
-}

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

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

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

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

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