@getollie/cli 0.0.1

package/library/management_systems-frontend_backend_platforms/file-upload-download-management-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 683,
+  "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 purposes. Please develop an online file upload and download management system where users can upload files through a front-end interface, with support for displaying current upload progress and file size. Administrators should be able to view all uploaded files through a back-end interface, with functionality for file downloading and deletion.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the file upload functionality fully implemented?",
+      "description": "Evaluate whether the code correctly implements file selection, validation, and upload to server. Check for multiple file upload support, file type restrictions, file size limits, and proper error handling when uploads fail. Score 0 if core upload functionality is missing, 5 if basic upload works but lacks validation, 10 if all features including proper validation and error handling are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the progress tracking feature properly implemented?",
+      "description": "Check if the upload progress is accurately displayed with real-time updates. Verify implementation of progress bar or percentage indicators that update dynamically using XHR/Fetch with progress events. Assess if the system shows current upload speed and estimated time remaining. Deduct 5 points if progress updates aren't real-time, 3 points if speed/time estimates are missing. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the file download functionality correctly implemented?",
+      "description": "Review whether users can download files with proper content disposition headers, correct MIME types, and optional download progress indicators. Check if large file downloads are handled efficiently (streaming vs. full memory load). Deduct 5 points if downloads lack proper headers or MIME types, 5 points if large files cause memory issues. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the admin management interface comprehensive and secure?",
+      "description": "Evaluate if the admin interface provides complete file management capabilities including listing, sorting, searching, downloading, and deletion. Check for proper authentication and authorization mechanisms to protect the admin functions. Deduct 5 points if search/sort functionality is missing, 5 points if authentication is weak or absent, 3 points if bulk operations aren't supported. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruptions, server errors, invalid file types, oversized files, 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. Drag-and-drop upload support 2. Image/document previews 3. Client-side file compression 4. Resumable uploads for large files 5. Dark/light mode toggle). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple file upload handlers) 2. Function modules unrelated to file management (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., excessive animations on file listings). 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 components/API services/state management), error handling patterns, and code organization. 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 proper security measures for file uploads are missing (like sanitization). 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 file listing and preview design (clear hierarchical information display). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic file listing layouts. 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) Upload button and drag area clearly visible 2) File status changes (queued, uploading, complete, error) with clear visual feedback 3) Smooth transitions between upload states with appropriate animations (300-500ms). Deduct 5 points for each operation without feedback, 3 points for jarring transitions between states, and 5 points for confusing status indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "easy"
+}

package/library/management_systems-frontend_backend_platforms/film-crew-management-weather-scenes-gantt.json

@@ -0,0 +1,68 @@
+{
+  "index": 473,
+  "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. Develop a film and TV crew announcement management system that includes weather API displays for shooting locations and automatic costume-role associations with scenes. Include daily progress comparison with planned Gantt charts, with delayed scenes displaying impact factor tags (weather/actors/etc.).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core film and TV crew announcement management system fully implemented?",
+      "description": "Review whether the code accurately implements CRUD operations for crew announcements, schedule management, and role assignments. Check if the system supports different user roles (director, producer, crew members) with appropriate access controls. Score 0 if the core announcement system is not implemented, 5 if only basic announcement functions exist, and 10 if comprehensive management features are included with proper data validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the weather API integration properly implemented?",
+      "description": "Evaluate whether the weather API is correctly integrated with location-based data, showing current and forecasted conditions for shooting locations. Check if the code handles API rate limits, connection failures, and data caching. The implementation should include visual indicators for weather conditions affecting shooting. Deduct 5 points if the API integration is basic without error handling, 3 points if weather data is not linked to shooting locations properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the costume-role association with scenes functionality complete?",
+      "description": "Check if the system maintains a database of costumes and characters with proper relationships to scenes. The code should allow for automatic assignment based on scene requirements and handle conflicts. Verify if costume tracking includes availability status and maintenance schedules. Deduct 5 points if associations are manual only, 3 points if costume tracking lacks detail. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the progress comparison with Gantt charts and impact factor tagging implemented effectively?",
+      "description": "Review whether the code implements visual Gantt chart comparisons between planned and actual progress, with dynamic updates based on daily reports. Check if delayed scenes are properly tagged with impact factors (weather/actors/logistics/equipment) and if these tags are programmatically determined based on system data. Deduct 5 points if Gantt visualization is static, 5 points if impact factors are not automatically associated. 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 API failures, network interruptions, concurrent user edits, 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 notifications with priority system 2. AI-based schedule optimization suggestions 3. Visual weather impact projection). 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 notification systems coexisting) 2. Function modules unrelated to film crew management (e.g., a built-in game for waiting times) 3. Fancy effects that affect performance (e.g., unnecessary animations in critical workflow screens). 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/UI/data access 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/financial-management-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 506,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code can be executed as shown. ======== ROLE ========\nYou are an experienced code specialist. Given a software development requirement description, you are asked to generate project code based on these requirements. Strictly follow the rules to help users generate complete project code that is fully commented with simple, easy-to-understand language, without outputting anything else.\n\n======== OUTPUT RULES ========\n1. Always generate complete, runnable project code; ensure the project is fully executable\n2. Ensure all code files you output are complete, do not omit any code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot be executed or contains errors, regenerate it\n4. If the requirements involve external API access or need to use user data (images, videos, audio, etc.), please provide simulated data\n\n======== PROJECT REQUIREMENTS ========\nPlease write code to implement a financial management system where finance personnel can enter income and expense items and generate financial reports; administrators can view all financial records and perform data analysis and statistics.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the financial data management system fully implemented?",
+      "description": "Review whether the code accurately implements income and expense entry functionality through HTML/JavaScript forms, including data validation, category classification, and amount calculation. Check if it supports multiple transaction types (income/expense), date selection, description fields, and category management. Score 0 if core financial entry logic is not implemented, 5 if only basic income/expense recording is available, and 10 if comprehensive financial transaction management with validation is fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the financial report generation function implemented?",
+      "description": "Evaluate whether the system can generate comprehensive financial reports including income statements, expense summaries, and period-based analysis. Check for chart visualization (pie charts, bar charts, line graphs), export functionality (PDF/Excel), and customizable date ranges. Deduct 5 points if no visual charts are provided, and 3 points if export functionality is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the role-based access control and user management designed?",
+      "description": "Check whether the system implements proper role separation between finance personnel and administrators, with appropriate permission controls. Finance staff should only access entry and basic reports, while administrators can view all records and perform advanced analytics. Deduct 5 points if role authentication is missing, and 3 points if permission boundaries are not properly enforced. Verify login/logout functionality and session management. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the data analysis and statistics module constructed?",
+      "description": "Evaluate whether the code includes comprehensive data analysis features such as trend analysis, category-wise spending patterns, monthly/yearly comparisons, and statistical summaries. Check for filtering capabilities, search functionality, and advanced analytics like budget vs actual comparisons. Deduct 5 points if only basic listing is provided without analysis, and 3 points if statistical calculations are inaccurate. Give 10 points if fully implemented with interactive analytics.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid financial amounts, date format errors, unauthorized access attempts, data corruption, 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 financial management experience (e.g., 1. Automated expense categorization using AI 2. Budget alerts and notifications 3. Receipt image upload and OCR processing 4. Financial goal tracking 5. Multi-currency support). 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 logics coexisting) 2. Function modules unrelated to financial management (e.g., a built-in game or social features) 3. Fancy effects that affect performance (e.g., excessive animations on financial data). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core financial 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 layer/business logic/presentation layers), input validation, and code organization. Deduct 5 points if global state pollution is found or MVC patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no proper error handling or logging mechanisms exist. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the financial interface follows professional business application design: 1) Clean and trustworthy color scheme (preferably blues/grays for financial apps) 2) Proper data table layouts with clear headers and sorting 3) Professional typography (financial figures clearly readable, proper alignment). Deduct 3 points for each cluttered data presentation, 5 points for unprofessional color choices that reduce trust, and 5 points for poor number formatting or alignment. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the financial data interaction smooth and intuitive?",
+      "description": "Judge whether the financial operations are user-friendly: 1) Form submission feedback ≤ 100ms 2) Data loading states and progress indicators 3) Intuitive navigation between different financial views 4) Clear visual feedback for successful transactions. Deduct 5 points for each operation without proper feedback, 3 points for slow data rendering that affects user experience, and 5 points for confusing navigation that makes financial tasks difficult to complete. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}

package/library/management_systems-frontend_backend_platforms/fitness-club-membership-management-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 544,
+  "question": "You are a code expert. Please use your expertise to generate accurate and professional responses. Make sure the generated code is executable and displayable.\n\n## Role\nYou are an experienced code expert. You are provided with a software development requirement description, and you are required to generate project code based on these requirements. Follow the rules strictly to help users generate a complete project code with simple and understandable comments, and don't output anything else.\n\n## Output Rules\n1. You should always generate complete, runnable project code. Please ensure the project is fully executable.\n2. Ensure all code files you output are complete, don't omit any code.\n3. Before final output, carefully review and check all code to evaluate its executability. If the code cannot be executed or contains errors, regenerate it.\n4. If the requirements involve external API access or need to use user data (images, videos, audio, etc.), please provide simulated data.\n\n## Project Requirements Description\nPlease write code to implement a fitness club membership management system. Administrators can add, delete, and edit member information, manage course registrations and attendance records. Members can log in to view available courses, register for courses, and check their own attendance and course records. The system should support a course scheduling calendar, automatically remind members of upcoming courses, and generate member attendance statistical reports.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the member management system fully implemented?",
+      "description": "Review whether the code accurately implements CRUD operations for member profiles, including name, contact information, membership status, payment records, and membership expiry tracking. Score 0 if core member management is missing, 5 if basic functionality is implemented but lacks validation or proper data relationships, and 10 if all member management features are fully implemented with data integrity checks.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the course management system properly implemented?",
+      "description": "Check if the system can handle course creation, scheduling, capacity management, instructor assignment, and course descriptions. Validate if the code implements proper validation for course scheduling conflicts, room availability, and instructor availability. Deduct 3 points if scheduling conflict detection is missing, 3 points if capacity management is incomplete, and 2 points if instructor assignment logic is flawed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the attendance tracking system complete?",
+      "description": "Evaluate if the system can record member attendance, handle check-ins/check-outs, track no-shows, and provide attendance history. Check whether the system implements proper date/time handling for accurate attendance tracking. Deduct 3 points if attendance records can't be queried by date ranges, 3 points if attendance status validation is missing, and 2 points if the system lacks attendance modification audit trails. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the notification and reminder system implemented?",
+      "description": "Assess whether the code includes course reminder functionality, including configurable reminder timing (e.g., 24 hours before class), multiple notification channels (email/SMS/in-app), and handling of notification delivery failures. Deduct 3 points if only one notification channel is implemented, 3 points if notification scheduling is hardcoded, and 2 points if there's no notification status tracking. 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 concurrent user edits, invalid data inputs, network interruptions, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include comprehensive input validation, transaction management for database operations, and graceful error handling, 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. Automated fitness progress tracking 2. Personalized class recommendations based on attendance history 3. Virtual class waitlist with priority algorithms 4. Integration with wearable fitness devices). 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 user authentication systems) 2. Function modules unrelated to fitness club management (e.g., a built-in general chat system) 3. Fancy effects that affect performance (e.g., unnecessary animations in reporting views). 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 access 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/fixed-deposit-system-react-spring-boot.json

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

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

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

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