@getollie/cli 0.0.4 → 0.2.0

package/library/management_systems-frontend_backend_platforms/fixed-deposit-system-react-spring-boot.json

@@ -1,68 +0,0 @@
-{
-  "index": 839,
-  "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 implement a fixed deposit system with operations including entry, cancellation, full/partial early settlement, full settlement, additional deposits, reduced extensions, etc. The frontend should use React, Ant Design, and TypeScript, while the backend should be implemented with Spring Boot 2.7.7, MyBatis, and MySQL. Ensure all mappers use annotations and all POJOs use Lombok. Display all code in full without additional explanations or interpretations.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the fixed deposit core functionality implemented?",
-      "description": "Evaluate whether the code implements all the required core functionalities: deposit entry, cancellation, full/partial early settlement, full settlement, additional deposits, and reduced extensions. Each operation should have proper validation, transaction handling, and calculation logic. Score 0 if less than 3 core operations are implemented, 5 if only basic operations are present, and 10 if all specified operations with complete business rules are implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the interest calculation system accurate and complete?",
-      "description": "Check if the interest calculation logic handles different scenarios correctly: regular interest accrual, early withdrawal penalties, additional deposit adjustments, and term extensions. The system should use appropriate compounding methods and account for edge cases like leap years and partial months. Deduct 3 points if calculations don't handle decimal precision properly, 4 points if early withdrawal penalties are incorrect, and 5 points if the interest calculation fails on edge cases. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are all backend APIs and data persistence layers properly implemented?",
-      "description": "Verify that all necessary Spring Boot REST endpoints are created with proper request/response handling, all MyBatis mappers use annotations as required, and database schema design follows normalization principles. Check if transaction management is implemented for critical operations and appropriate error handling exists. Deduct 3 points for missing endpoints, 3 points for improper transaction handling, and 4 points for incorrect database design. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the React frontend implementation complete with all required screens and components?",
-      "description": "Assess whether all required screens are implemented: deposit creation, management dashboard, transaction history, settlement screens, etc. Check if TypeScript is properly used with appropriate interfaces and type definitions. Evaluate if Ant Design components are correctly implemented and follow the library's best practices. Deduct 3 points for each missing major screen, 3 points for improper TypeScript usage, and 4 points for inconsistent Ant Design implementation. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code handles common abnormal situations (invalid inputs, concurrent modifications, system failures, etc.) and provides appropriate error handling and recovery mechanisms. Check for input validation, exception handling, and proper error messages. Code with strong robustness should handle edge cases effectively. Give 10 points for comprehensive error handling, 5 points for average robustness, and 0 points if exceptions are not handled.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check for surprise features that enhance user experience (e.g., 1. Real-time interest calculation preview 2. Deposit maturity notifications 3. Interactive what-if scenarios for early withdrawals 4. Visual reporting of deposit performance). 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 interest calculation methods) 2. Function modules unrelated to fixed deposits (e.g., built-in currency converter not needed for core functionality) 3. Fancy effects that affect performance (e.g., unnecessary animations in a financial application). Deduct 3 points for each redundancy found, and directly deduct 10 points if core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review the code's architectural design (separation of concerns between frontend/backend, proper layering), adherence to TypeScript/Java coding standards, use of design patterns, test coverage, and build process automation. Check if Lombok is correctly used for all POJOs as required. Deduct 3 points if global state management is poor, 3 points if code duplication rate is high, 2 points if tests are missing, and 2 points if Lombok is misused. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the Ant Design implementation follows professional financial application design principles: 1) Consistent use of Ant Design's design language 2) Clear information hierarchy for financial data 3) Professional typography suitable for financial figures (monospaced fonts for numbers, proper decimal alignment). Deduct 3 points for inconsistent component styling, 3 points for poor information density in financial views, and 4 points for inaccessible or hard-to-read financial data displays. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the React application provides appropriate user feedback: 1) Loading states during API calls 2) Form validation feedback 3) Confirmation dialogs for critical financial operations 4) Smooth transitions between application states. Deduct 3 points for missing loading indicators, 3 points for abrupt state changes, and 4 points for lack of confirmation mechanisms for critical financial transactions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "medium"
-}

package/library/management_systems-frontend_backend_platforms/flight-operation-guide-with-backup-and-search.json

@@ -1,68 +0,0 @@
-{
-  "index": 1810,
-  "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. Could you create an HTML implementation of a standard flight operation guide that facilitates adding backups, searching, easy reference, and special notifications for specific requirements?",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core flight operation guide structure properly implemented?",
-      "description": "Review whether the HTML implementation correctly organizes flight operation procedures into logical sections (pre-flight, in-flight, post-flight) with proper hierarchical structure. Check if the content is properly structured using semantic HTML (headings, sections, lists) and if it follows aviation industry standards for organizing procedural information. Score 0 if no logical structure exists, 5 if basic organization is present, and 10 if the structure follows industry standards with complete procedural categorization.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the backup functionality fully implemented?",
-      "description": "Evaluate the mechanism for creating, storing, and retrieving backups of the flight operation guide. Check if the implementation includes local storage options (localStorage, IndexedDB), cloud synchronization capabilities, and version control features. Deduct 5 points if the backup feature lacks data persistence beyond the current session, 3 points if it doesn't include timestamp/versioning, and 2 points if there's no way to compare or restore previous versions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "How effective is the search functionality?",
-      "description": "Assess the search implementation for the flight operation guide. Check for features like real-time filtering, keyword highlighting, search history, and advanced search options (category filtering, date ranges, etc.). The search should handle case sensitivity, partial matches, and provide relevant sorting of results. Deduct 5 points if search doesn't filter content in real-time, 3 points if it lacks highlighting of results, and 2 points if it doesn't support partial word matching. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the special notifications system adequately implemented?",
-      "description": "Review the notification system for alerting users about critical updates, changes to procedures, or emergency protocols. Check if the notifications are prioritized by urgency, if they persist until acknowledged, and if they can be triggered by specific conditions. Deduct 5 points if notifications aren't visually distinct based on priority levels, 3 points if there's no acknowledgment tracking, and 2 points if the system lacks notification history. 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 offline usage, browser crashes, invalid user input, 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. Dark mode for night operations 2. Text-to-speech reading of procedures 3. Integration with weather APIs for real-time conditions). 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 search methods that do the same thing) 2. Function modules unrelated to flight operations (e.g., unnecessary entertainment features) 3. Fancy effects that affect performance (e.g., intensive animations that slow down critical operations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating data/view/controller layers), cross-browser compatibility, responsive design for different devices used in cockpits, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code isn't responsive for different screen sizes; deduct 5 points if the application isn't performant with large amounts of procedural data. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional aviation standards?",
-      "description": "Evaluate whether the overall design follows aviation industry UI principles: 1) High contrast for readability in various lighting conditions 2) Consistent color coding for different procedure types/priorities 3) Professional typography with appropriate sizing for in-flight reading (min 16px). Deduct 3 points for each readability issue, 5 points for inconsistent color systems that could cause confusion, and 5 points for cluttered interfaces that hinder quick information access. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and optimized for operational use?",
-      "description": "Judge whether the interaction design prioritizes operational efficiency: 1) Minimal clicks to access critical information (≤ 3 clicks) 2) Quick-access shortcuts for emergency procedures 3) Touch-friendly targets (min 44px) for tablet use in cockpit environments. Deduct 5 points for each critical function requiring excessive navigation, 3 points for interactions lacking visual/tactile feedback, and 5 points for non-intuitive gesture implementations. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "medium"
-}

package/library/management_systems-frontend_backend_platforms/food-delivery-robot-car-joystick-control.json

@@ -1,68 +0,0 @@
-{
-  "index": 1456,
-  "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 for demonstration. Background: A food delivery robot car project with an architecture consisting of: Frontend using uniapp vue3 js, API using Django, database using Django's built-in sqlite, service using MQTT, and ROS1. Your task is to implement functionality through MQTT, JS, ROS1, and ROS-JS that enables remote control of the robot car through a tablet mini-program using a joystick controller.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the MQTT communication system properly implemented?",
-      "description": "Evaluate whether the MQTT implementation includes proper topic design, QoS levels configuration, retained message handling, and client identification. Check for proper handling of connection states, disconnection events, and reconnection logic. The system should implement a proper publish-subscribe pattern with appropriate topic filtering.Score 0 if MQTT is not implemented, 5 if basic MQTT communication is established but lacks robust handling, and 10 if it includes comprehensive topic hierarchy design, proper QoS configuration (QoS 1 or 2 for critical controls), error handling, and connection state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the joystick controller interface correctly implemented?",
-      "description": "Review the implementation of the joystick controller UI component in uniapp/vue3. Check whether it captures all necessary inputs (directional movement, speed control), has proper touch/drag event handling, provides visual feedback, and handles multi-touch scenarios. Verify the controller includes proper deadzone handling and input normalization.Score 0 if the joystick is not implemented, 5 if basic joystick functionality exists but lacks precision controls or visual feedback, and 10 if the joystick includes proper event handling, visual feedback, configurable sensitivity, deadzone handling, and graceful degradation for different screen sizes.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the ROS1 integration with MQTT correctly implemented?",
-      "description": "Examine whether the code properly bridges MQTT messages to ROS topics/services and vice versa. Check if ROS nodes are correctly initialized, if message types match between systems, and if transformations between JSON and ROS message formats are handled accurately. Verify that the system handles ROS connection issues gracefully.Score 0 if ROS integration is missing, 5 if basic bridging exists but without error handling or type validation, and 10 if there's complete bidirectional communication with proper message type handling, parameter validation, and error recovery mechanisms.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the ROS-JS bridge properly implemented for real-time control?",
-      "description": "Assess whether the ROS-JS bridge properly handles websocket connections, manages connection lifecycle, provides proper security measures, and ensures minimal latency for robot control. Check if the implementation includes throttling mechanisms to prevent command flooding and handles network interruptions gracefully.Score 0 if the ROS-JS bridge is not implemented, 5 if a basic bridge exists but with noticeable latency (>200ms) or reliability issues, and 10 if the implementation ensures low-latency communication (<100ms), handles connection issues gracefully, and includes proper security measures and command throttling.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (network interruptions, sensor failures, invalid user inputs, etc.) and provides graceful degradation or recovery mechanisms. Check for proper error logging, user notification, and fallback controls.Give 0 points if exceptions are not handled, 5 points if basic error handling exists but recovery is manual, and 10 points if comprehensive error handling with automatic recovery mechanisms is implemented for all critical components.",
-      "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. Visual trajectory planning 2. Real-time obstacle avoidance visualization 3. Configurable autonomous behaviors 4. Telemetry dashboard with robot status).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 control schemes overlapping) 2. Function modules unrelated to robot control (e.g., unnecessary social features) 3. Fancy effects that affect performance (e.g., heavy animations that impact control responsiveness).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 (separation of UI/control logic/communication layers), code reusability, documentation quality, and maintainability. Check for proper version control practices, testing coverage, and build process automation.Deduct 3 points if global state pollution is found; deduct 3 points if design patterns are not properly used; deduct 2 points if code duplication rate is over 30%; deduct 2 points if documentation is insufficient. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the tablet mini-program UI follows modern design principles: 1) Harmonious color matching appropriate for robot control interface 2) Proper layout with clear hierarchy of controls 3) Appropriate visual feedback for control states 4) Responsive design that works across tablet orientations.Deduct 3 points for poor control placement or sizing, 3 points for confusing visual hierarchy, 2 points for lack of visual feedback on actions, and 2 points for poor responsiveness across orientations. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the control system responsive with appropriate latency management?",
-      "description": "Judge whether the control system provides immediate feedback and handles latency appropriately: 1) Command execution delay ≤ 200ms 2) Visual feedback of command receipt within 50ms 3) Proper handling of command queuing during network instability 4) Appropriate emergency stop functionality.Deduct 3 points if command feedback exceeds 200ms, 3 points for lack of visual command acknowledgment, 2 points for poor network instability handling, and 2 points for inadequate emergency controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "medium"
-}

package/library/management_systems-frontend_backend_platforms/food-flavoring-formulation-generator.json

@@ -1,68 +0,0 @@
-{
-  "index": 1015,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration purposes. Create a program for developing food flavorings that can provide appropriate formulations whenever specific flavor profile requirements are submitted.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the flavor profile analysis system properly implemented?",
-      "description": "Review whether the code accurately implements a flavor classification system using appropriate data structures (arrays/objects/classes), capable of analyzing input requirements and mapping them to potential ingredients. Score 0 if there's no systematic flavor categorization, 5 if there's basic classification but without nuanced relationships, and 10 if the system includes comprehensive flavor profiles with appropriate relationships (sweet/sour/umami/bitter/salty) and intensity levels.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the ingredient compatibility matrix implemented?",
-      "description": "Evaluate whether the code includes a compatibility matrix between ingredients that handles complementary and contrasting flavor interactions. Check if the system can identify which ingredients work well together and which conflict. Deduct 5 points if there's no compatibility logic, 3 points if only basic pairing is implemented without addressing conflicts. The full score is 10 points if it includes weighted compatibility scores with synergistic effects.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the formulation generation algorithm effective?",
-      "description": "Check if the algorithm can process flavor requirements and generate appropriate proportioned formulations. The algorithm should optimize for the requested flavor profile while maintaining balance. Deduct 5 points if the algorithm only provides fixed recipes, 3 points if it doesn't adjust for ingredient intensity. Full score of 10 points requires dynamic formulation with appropriate ratios and alternative suggestions.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a customization interface for flavor profile requirements?",
-      "description": "Assess whether the program includes a user-friendly interface for specifying flavor requirements, including sliders/inputs for different flavor dimensions, target applications, and intensity preferences. Deduct 5 points for command-line only interfaces, 3 points for limited input options. Give 10 points if the interface allows for detailed flavor profiling with visual representation of the resulting flavor balance.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, missing ingredients, conflicting requirements, 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. Visual flavor profile mapping 2. Ingredient substitution recommendations 3. Historical flavor trend analysis). 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 calculation methods for the same flavor profile) 2. Function modules unrelated to flavor development (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., unnecessary animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating flavor analysis logic/UI/data components), 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": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "medium"
-}

package/library/management_systems-frontend_backend_platforms/food-ordering-restaurant-program.json

@@ -1,68 +0,0 @@
-{
-  "index": 810,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable and can be demonstrated. I've just created a project, but it has only one typical template that isn't helpful for me. I need to write a small program that allows for ordering food like in a restaurant.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the restaurant order system's core functionality fully implemented?",
-      "description": "Review whether the code implements the essential features of a food ordering system including menu display, item selection, cart management, and order submission. Score 0 if these core interactions are missing, 5 if only basic item selection is implemented, and 10 if the complete ordering flow is present with proper state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the menu data structure and display properly designed?",
-      "description": "Evaluate whether the menu is structured logically (e.g., with categories, item descriptions, prices, and images) and displayed in an easily navigable format. Check if items can be filtered or searched. Deduct 5 points if the menu is just a flat list without categories, 3 points if item details are incomplete, and 2 points if no search/filter functionality exists. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the cart and order management system comprehensive?",
-      "description": "Check if the system allows adding/removing items from the cart, changing quantities, displaying subtotals and totals, and applying special requests or customizations. Verify that the order confirmation process includes a review step. Deduct 3 points if quantity modification isn't supported, 3 points if no order summary is shown, and 4 points if item customization is not possible. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a user authentication and order history feature?",
-      "description": "Assess whether the system includes user accounts, login functionality, and the ability to view past orders. Check if users can reorder previous meals and if guest ordering is supported as an alternative. Deduct 5 points if user authentication is missing, 3 points if order history isn't implemented, and 2 points if no guest ordering option exists. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common edge cases (such as empty cart checkout attempts, invalid input values, network errors when fetching menu data, etc.) and provide friendly error messages. Code with strong error handling should receive 10 points. If only basic validation exists, give 5 points, and if no error handling is implemented, 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 order status tracking 2. Dietary preference filters 3. Estimated preparation time calculator 4. Meal recommendation system based on past orders). 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 cart management logics) 2. Function modules unrelated to food ordering (e.g., a built-in game while waiting) 3. Fancy effects that affect performance (e.g., excessive animations when adding items to cart). 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/state management/data handling), component reusability, and code organization. Deduct 5 points if global state is poorly managed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear project structure or naming conventions. 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 scrolling through menu items, and 5 points for hard-to-find key function buttons like 'Add to Cart' or 'Checkout'. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "easy"
-}

package/library/management_systems-frontend_backend_platforms/form-management-system-low-code-platform.json

@@ -1,68 +0,0 @@
-{
-  "index": 1666,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration purposes. Help design a form management system, similar to those in low-code platforms.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core form builder functionality properly implemented?",
-      "description": "Check if the code includes essential form components (inputs, checkboxes, selects, etc.) with proper data binding and validation. Form elements should have proper attributes including labels, placeholders, and accessible markup. Score 0 if the form builder core is missing, 5 if only basic elements are included, and 10 if a comprehensive component library with validation is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is drag-and-drop functionality for form construction implemented?",
-      "description": "Evaluate whether the system includes intuitive drag-and-drop functionality for arranging form elements. This should include element positioning, nesting capabilities, and grid/layout management. Deduct 5 points if drag-and-drop is missing, 3 points if it's rudimentary without proper visual feedback. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is form data management and submission handling implemented?",
-      "description": "Assess the implementation of form data management including state management, data validation, conditional logic, and submission handling. Look for features like form state persistence, API integration options, and error handling during submission. Deduct 5 points if validation is missing, 3 points if conditional logic is absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are form templates and saving/loading mechanisms provided?",
-      "description": "Check if the system includes template management functionalities such as saving forms as templates, loading existing templates, and importing/exporting form configurations (JSON/XML). Deduct 5 points if export/import is missing, 3 points if there's no template library. Give 10 points if fully implemented with version control.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid form configurations, network failures during submission, 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. AI-assisted form creation 2. Accessibility checker with recommendations 3. Multi-device preview mode). 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 form components (e.g., multiple text input implementations) 2. Function modules unrelated to form management (e.g., unnecessary image galleries) 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 form model/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": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "hard"
-}

package/library/management_systems-frontend_backend_platforms/fresh-food-supermarket-checkout-system.json

@@ -1,68 +0,0 @@
-{
-  "index": 1713,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure the code you generate is executable for demonstration. Help me write a small checkout system for a fresh food supermarket, and explain how to use it.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core checkout functionality properly implemented?",
-      "description": "Review whether the code accurately implements essential checkout features including product scanning/input, price calculation, discount application, and receipt generation. Check if the system can handle different product types (weighted vs. unit items). Score 0 if core functionality is missing, 5 if basic checkout works but has limitations, 10 if fully functional with proper error handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the product inventory management system implemented?",
-      "description": "Evaluate whether the code includes a proper inventory system that tracks product details (name, price, stock level, category, etc.) and updates inventory after checkout. Check for CRUD operations for managing products. Deduct 5 points if there's no stock tracking, 3 points if product data structure is inadequate. Full score requires persistent storage implementation.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are discount and promotion mechanisms implemented?",
-      "description": "Check if the system supports various discount types (percentage, fixed amount, buy-X-get-Y, etc.) and can apply them correctly during checkout. Verify if promotions can be time-limited and combined according to rules. Deduct 5 points if only basic discounts are implemented, 3 points if discount conflict resolution is missing. Full score requires flexible promotion rule configuration.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the user interface intuitive and functional for supermarket staff?",
-      "description": "Assess if the interface provides clear visual feedback during checkout, allows quick product lookup/scanning, and presents relevant information in a logical layout. Check if common supermarket operations like price overrides and quantity adjustments are easily accessible. Deduct 5 points for confusing navigation, 3 points for poor information hierarchy, and 5 points for missing critical interface elements.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (e.g., invalid product codes, network issues during checkout, payment processing errors) and provides friendly error messages or recovery mechanisms. 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 code includes surprise features that enhance the experience (e.g., 1. Real-time inventory analytics 2. Customer loyalty program integration 3. Mobile receipt options). 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 price calculation methods) 2. Function modules unrelated to checkout (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., unnecessary animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating business logic/view/data layers), unit test coverage, and potential for scalability. 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 error handling is inconsistent. 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 POS system principles: 1) Clean and high-contrast UI suitable for retail environments 2) Proper layout with logical grouping of related functions 3) Consistent visual language across all screens. Deduct 3 points for each cluttered screen, 5 points for poor readability under various lighting conditions, and 5 points for inconsistent interface elements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and efficient for high-volume checkout?",
-      "description": "Judge whether the system optimizes for checkout speed: 1) Fast response time (≤ 100ms) for scanning/entry 2) Minimal steps for common operations 3) Keyboard shortcuts for frequently used functions. Deduct 5 points for each operation requiring more than 3 clicks/steps, 3 points for lack of input validation feedback, and 5 points if the system slows down with larger transactions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "hard"
-}

package/library/management_systems-frontend_backend_platforms/frontend-backend-hospital-dip-software.json

@@ -1,68 +0,0 @@
-{
-  "index": 905,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Note that any code you generate should be executable. Help me design a front-end and back-end separated hospital DIP (Diagnosis-related Groups) grouping software.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the DRG grouping algorithm correctly implemented?",
-      "description": "Review whether the code accurately implements the DRG grouping logic including ICD-10 diagnosis code parsing, procedure code classification, and patient demographic factor weighting. Check if the grouping tree traversal algorithm correctly handles complex medical scenarios (comorbidities, complications, age stratification). Score 0 if core grouping logic is missing, 5 if only basic classification is implemented, and 10 if full DRG specification compliance including MDC (Major Diagnostic Categories) and relative weight calculations are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the medical data processing and validation system robust?",
-      "description": "Evaluate whether the system properly validates medical coding inputs (ICD-10-CM/PCS format validation), handles data standardization, and implements medical terminology mapping. Check for proper handling of incomplete medical records, duplicate entries, and cross-referencing between diagnosis and procedure codes. Deduct 5 points if medical data integrity checks are missing, 3 points if standardization protocols are not implemented. Full score requires comprehensive medical data quality assurance.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the hospital workflow integration properly designed?",
-      "description": "Check whether the system integrates with typical hospital information systems (HIS/EMR) through proper APIs, supports batch processing of patient records, and provides real-time grouping results. Evaluate if the workflow supports different user roles (physicians, coders, administrators) with appropriate access controls. Deduct 5 points if API integration is incomplete, 3 points if batch processing is inefficient. Requires seamless integration with existing hospital IT infrastructure.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are comprehensive reporting and analytics features implemented?",
-      "description": "Assess whether the system provides detailed DRG distribution reports, cost analysis dashboards, case mix index calculations, and trend analysis over time. Check for export capabilities (PDF, Excel), customizable report templates, and statistical summaries for hospital management. Deduct 5 points if reporting lacks depth, 3 points if visualization components are missing. Full implementation should include executive dashboards and operational reports.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid medical codes, system timeouts, corrupted patient data, concurrent user operations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle these edge cases including graceful degradation during system failures, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the healthcare workflow experience (e.g., 1. AI-powered coding suggestions 2. Real-time DRG impact prediction during patient admission 3. Interactive case complexity visualization 4. Automated coding discrepancy detection). Add 3 points for each practical innovative feature implemented that adds genuine value to hospital operations (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 patient search mechanisms coexisting) 2. Function modules unrelated to DRG grouping (e.g., built-in patient scheduling system) 3. Fancy effects that affect performance (e.g., heavy animations in data tables). Deduct 3 points for each redundancy found, and directly deduct 10 points if core medical 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 business logic/data access/presentation layers), unit test coverage for critical medical algorithms, API documentation quality, and deployment automation. Deduct 5 points if global state pollution is found or proper architectural patterns are not used; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if deployment process is not automated or lacks proper environment configuration. Full score requires enterprise-grade code quality.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface design meet healthcare professional standards?",
-      "description": "Evaluate whether the design follows healthcare UI/UX best practices: 1) Clinical color scheme (avoiding red/green confusion for medical professionals) 2) High contrast ratios for accessibility (WCAG 2.1 AA compliance) 3) Medical data presentation standards (proper table layouts, clear hierarchy). Deduct 3 points for each accessibility violation, 5 points for poor medical data readability, and 5 points for non-intuitive navigation that could impact clinical workflow. Full score requires healthcare-specific design considerations.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to healthcare professional workflow needs: 1) Form submission feedback delay ≤ 100ms 2) Data loading transitions controlled between 300-500ms 3) Clear visual indicators for data processing states 4) Intuitive navigation between patient records. Deduct 5 points for each operation without proper feedback, 3 points for laggy data table interactions, and 5 points if critical functions are hard to locate during busy clinical workflows. Full score requires seamless user experience optimized for healthcare environments.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "hard"
-}