@getollie/cli 0.0.1

package/library/management_systems-frontend_backend_platforms/create-web-based-information-management-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 1622,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to make the code you generate executable for demonstration purposes. How do I write a simple web-based information management system?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core CRUD functionality fully implemented?",
+      "description": "Review whether the code implements all four basic operations (Create, Read, Update, Delete) for managing information entities. Check if form validation exists for data entry, and if data retrieval supports filtering and sorting. Score 0 if core operations are missing, 5 if basic operations exist without validation, and 10 if all operations are implemented with proper validation and error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is there a proper database integration or data persistence mechanism?",
+      "description": "Evaluate whether the code includes database connectivity (SQL or NoSQL) or alternative data persistence methods (like localStorage for demo purposes). Check for prepared statements or ORM to prevent SQL injection. Deduct 5 points if data persistence is completely missing, 3 points if it's implemented but without security considerations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there user authentication and authorization functionality?",
+      "description": "Check if the system implements user login/registration with proper password hashing, session management, and role-based access control. Examine whether different user roles have appropriate access restrictions. Deduct 5 points if authentication is missing, 3 points if it exists but with security flaws (like plaintext passwords). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the application architecture well-structured?",
+      "description": "Assess if the code follows a clear architectural pattern (MVC, MVVM, etc.) with separation of concerns. Look for proper modularization between data access, business logic, and presentation layers. Deduct 5 points for monolithic code without layer separation, 3 points if some structure exists but with significant coupling issues. The 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, server errors, network issues, etc.) and provides friendly error messages. Check for input sanitization to prevent XSS attacks. 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 data visualization 2. Export functionality to PDF/Excel 3. Dark mode toggle 4. Responsive design for mobile compatibility). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to perform the same search) 2. Function modules unrelated to information management (e.g., a built-in game) 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 code organization (file/folder structure), naming conventions, commenting practices, and reusability. Check for dependency management and build process. Deduct 5 points if global variables are overused; deduct 5 points if the code lacks comments or has poor naming; deduct 5 points if there's no clear build/deployment strategy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional standards?",
+      "description": "Evaluate whether the UI follows modern design principles: 1) Consistent color scheme (no more than 3 primary colors) 2) Proper white space and layout (following grid systems) 3) Typography hierarchy (clear difference between headings, body text). Deduct 3 points for cluttered layouts, 5 points for inconsistent styling across pages, and 5 points for poor information hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the user experience intuitive and efficient?",
+      "description": "Judge whether the system prioritizes usability: 1) Navigation is clear and consistent 2) Forms have proper validation with instant feedback 3) Loading states are indicated 4) Confirmation is required for destructive actions. Deduct 5 points for confusing navigation, 3 points for missing feedback on user actions, and 5 points for workflows that require excessive clicks. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "easy"
+}

package/library/management_systems-frontend_backend_platforms/customer-salesperson-login-welcome-page.json

@@ -0,0 +1,68 @@
+{
+  "index": 1009,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Ensure that the generated code is executable for demonstration. First, complete the registration and login modules: for individual customers/corporate customers/individual salespeople, provide complete page files. The welcome page should include a redirect button for \"I am a customer, I want to buy insurance\" and a redirect button for \"I am a salesperson, I want to sell insurance\". Modular development is required. Provide the complete file for the welcome page.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the welcome page with proper redirects fully implemented?",
+      "description": "Evaluate if the welcome page includes clearly visible and properly styled redirect buttons for 'I am a customer, I want to buy insurance' and 'I am a salesperson, I want to sell insurance'. Check if clicking these buttons correctly redirects users to appropriate registration/login pages. Score 0 if no welcome page is provided, 5 if the page exists with basic redirects, and 10 if the welcome page is comprehensive with proper routing, responsive design, and intuitive navigation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all registration modules for different user types implemented?",
+      "description": "Verify the implementation of registration forms for all specified user types: individual customers, corporate customers, and individual salespeople. Each form should include appropriate fields (e.g., personal details for individuals, company information for corporate users). Assess validation logic for each field (email format, password strength, required fields). Deduct 3 points for each missing user type registration, and 2 points for inadequate validation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are login modules for all user types functional?",
+      "description": "Check if login functionality exists for all user types with proper authentication logic. Evaluate if login forms include username/email and password fields, 'remember me' option, and 'forgot password' link. Test if authentication errors display appropriate messages. Deduct 3 points for each missing user type login, 2 points if error handling is inadequate, and 2 points if session management is not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is modular development properly implemented?",
+      "description": "Assess code organization: components should be properly separated, reusable, and follow a logical structure (e.g., separate components for forms, buttons, headers). Check if CSS is modularized (using CSS modules, styled-components, or similar approaches). Verify imports/exports are correctly used. Deduct 5 points if code is monolithic rather than modular, 3 points if styling is not modularized, and 3 points if there's significant code duplication. 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 form validation errors, network issues during login/registration, browser compatibility issues). Test edge cases (e.g., submitting empty forms, very long inputs). Code with strong robustness should provide friendly error prompts and recovery mechanisms. Give 10 points if thoroughly handled, 5 points if basic validation exists but edge cases are missed, and 0 points if no error handling is implemented.",
+      "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. Multi-factor authentication 2. Social media login integration 3. Personalized welcome messages 4. Interactive onboarding tour 5. Localization/language selection). 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 validation systems) 2. Function modules unrelated to registration/login (e.g., unnecessary widgets) 3. Fancy effects that affect performance (e.g., heavy animations that slow page loading). 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 (separate components for UI, business logic, and data handling), code organization, naming conventions, and commenting quality. Assess if the code follows industry standard patterns (e.g., React component patterns). Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is high; deduct 5 points if variable/function naming is inconsistent or unclear. 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 form design (clear labels, appropriate input sizes, visible focus states) 4) Consistent typography (heading hierarchy, readable font sizes). Deduct 3 points for each design inconsistency, 5 points for accessibility issues (poor contrast, missing ARIA attributes), and 5 points for unprofessional visual appearance. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the form interactions and page transitions conform to user expectations: 1) Form submission feedback is immediate 2) Error messages appear inline near relevant fields 3) Loading states are visually indicated 4) Transitions between pages are smooth. Deduct 5 points for abrupt page changes without feedback, 3 points for delayed form validation feedback, and 5 points for confusing navigation flow. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "easy"
+}

package/library/management_systems-frontend_backend_platforms/data-center-server-management-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 485,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. Please implement a data center server management system where employees can view the real-time operating status of company servers (CPU usage, memory usage, etc.) through a front-end page; administrators can log into the backend system to manually update server information, display historical performance logs of servers, and mark server health status.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the real-time server monitoring dashboard successfully implemented?",
+      "description": "Evaluate whether the front-end visualization properly displays real-time metrics (CPU usage, memory usage, etc.) with appropriate charts and gauges. Check if WebSocket or polling mechanism is implemented for real-time updates. Score 0 if no visualization exists, 5 if only basic static displays are implemented, and 10 if the dashboard shows comprehensive real-time metrics with appropriate refresh mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the admin management backend system fully functional?",
+      "description": "Review whether the admin panel includes secure authentication, server information update forms, and proper validation. Check for CRUD operations on server entries and whether the UI provides clear feedback after operations. Score 3 points for basic authentication, 3 points for complete server management forms, and 4 points for proper validation and error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the historical performance logging and visualization implemented?",
+      "description": "Check if the system stores and displays historical performance data with time-series charts. Evaluate whether filtering by date ranges, server IDs, and metric types is supported. Verify if data aggregation for different time periods (hourly, daily, weekly) is implemented. Score 0 if missing, 5 for basic logs without visualization, and 10 for comprehensive historical data analysis with interactive charts.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the server health status marking and alerting system functioning?",
+      "description": "Review if admins can mark server health statuses (healthy, warning, critical) and if the system has automated threshold-based alerts. Check if notifications are delivered through the UI and possibly email/SMS. Score 3 points for manual status marking, 4 points for threshold configuration, and 3 points for a functional alert delivery system.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles edge cases such as server disconnection, data inconsistencies, permission errors, and network issues. Check for proper error boundaries in the UI and graceful degradation. Score 10 points for comprehensive error handling, 5 points for basic error messages, and 0 points if exceptions aren't handled.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check for unique features such as: 1) Predictive analytics for server failures 2) Automated resource optimization suggestions 3) Interactive server topology map 4) Customizable dashboards for different roles. 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) Multiple implementations of the same monitoring functionality 2) Unnecessary data processing that impacts performance 3) Overly complex visualizations that don't add practical value. Deduct 3 points for each redundancy found, and directly deduct 10 points if core monitoring functionality is compromised by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separation of data fetching, state management, and UI components), code reusability, and maintainability. Check for consistent error handling patterns and appropriate use of design patterns. Deduct 5 points if global state is poorly managed; deduct 5 points if code duplication exceeds 30%; deduct 5 points if there's no separation between UI and business logic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the dashboard follows data visualization best practices: 1) Consistent color coding for status indicators 2) Proper information hierarchy with critical metrics prominently displayed 3) Responsive layout that works on different screen sizes. Deduct 3 points for misleading visualizations, 5 points for poor information density (too cluttered or too sparse), and 5 points for inaccessible color schemes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the system provides smooth user experience: 1) Immediate feedback for admin actions 2) Smooth transitions when switching between views 3) Loading states for asynchronous operations. Deduct 5 points for operations without visual feedback, 3 points for jerky transitions between dashboard states, and 5 points for UI freezes during data processing. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}

package/library/management_systems-frontend_backend_platforms/data-source-list-page-improved-design.json

@@ -0,0 +1,68 @@
+{
+  "index": 1410,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable for demonstration. Help me write a data source list page with an improved interface design, and also include the code file names.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the data list component fully implemented?",
+      "description": "Review whether the code implements a complete data list component including table structure, column headers, data rows, pagination, and sorting functionality. Score 0 if core list rendering is missing, 5 if only basic display is implemented without interactions, and 10 if the list includes proper data binding with dynamic rendering capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are filtering and search functions properly implemented?",
+      "description": "Check whether the implementation includes comprehensive data filtering mechanisms such as text search, dropdown filters, date range filters, and advanced filtering options. Deduct 3 points if only basic text search is available, 5 points if filters lack real-time feedback, and 7 points if there's no filter persistence between sessions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the data management functionality complete?",
+      "description": "Evaluate if the code implements CRUD operations (Create, Read, Update, Delete) for the data list. Check for proper form validation, confirmation dialogs for destructive actions, and optimistic UI updates. Deduct 5 points if any CRUD operation is missing, 3 points if validation is incomplete, and 2 points if there's no error handling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the interface design improved as requested?",
+      "description": "Assess whether the implementation includes significant UI/UX improvements over standard data lists such as responsive design, visual hierarchy, appropriate whitespace usage, and consistent styling. Deduct 5 points for using default/basic styling without customization, 3 points for inconsistent UI patterns, and 5 points for non-responsive designs. 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 empty data sets, network failures, large data volumes, 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. Inline data editing 2. Data visualization elements 3. Keyboard shortcuts for navigation/actions). 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 mechanisms) 2. Function modules unrelated to data listing (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating data/view/controller layers), component reusability, naming conventions, 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 file structure with appropriate file naming is missing. 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, 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": "easy"
+}

package/library/management_systems-frontend_backend_platforms/database-management-system-multi-db-support.json

@@ -0,0 +1,68 @@
+{
+  "index": 1417,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Database Management System with Multiple Database Support\n\nYou are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable and demonstrable whenever possible. Create a database management system using Java for the backend and Vue for the frontend that supports CRUD operations on databases. The system should support multiple database types including MySQL, Oracle, MongoDB, and Doris. Each database type can have multiple database instances. The interface should allow switching between databases to perform CRUD operations and executing queries across multiple databases. Please provide sample code for such a project.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the multi-database architecture properly implemented?",
+      "description": "Evaluate whether the system correctly implements an abstraction layer that can handle multiple database types (MySQL, Oracle, MongoDB, Doris). Check if the code includes proper connection management, interface adapters for each database type, and appropriate design patterns (like Factory, Adapter, or Strategy). Score 0 if only a single database type is supported, 5 if multiple databases are supported but with code duplication or tight coupling, 10 if a clean abstraction with proper inheritance or composition is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are database CRUD operations implemented completely across all database types?",
+      "description": "Review whether the code properly implements Create, Read, Update, and Delete operations for all required database types, handling the syntactical and structural differences between SQL databases (MySQL, Oracle) and NoSQL/analytical databases (MongoDB, Doris). Check for appropriate query builders or ORM implementations. Deduct 3 points for each database type with incomplete operations, and 5 points if transactions are not properly managed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the database instance management system properly implemented?",
+      "description": "Check if the system allows adding, configuring, connecting to, and removing multiple instances of each database type. Verify if connection pooling is implemented, credentials are securely stored, and connection status monitoring is available. Deduct 3 points if connection pooling is missing, 3 points if configuration management is incomplete, and 4 points if dynamic instance management is not supported. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is cross-database query functionality implemented?",
+      "description": "Evaluate whether the code supports executing queries across multiple databases, handling data transformation, result merging, and potential schema differences. Check if it includes proper query routing, distributed transaction management, and error handling for partial failures. Deduct 5 points if only sequential queries are supported without integration, 3 points if data transformation is incomplete, and 2 points if result presentation is not unified. 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 connection failures, query timeouts, syntax errors in user input, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include connection retry logic, query timeout handling, and user input validation. Give 10 points if all these are well-implemented, 5 points if only basic error handling exists, and 0 points if exceptions are not properly handled.",
+      "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 query builder 2. Real-time database performance monitoring 3. Schema comparison tools 4. Query optimization suggestions). 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 database access layers or duplicate connection management 2. Unnecessary middleware or libraries that add complexity without clear benefits 3. Overlapping functionality between frontend and backend validation. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core database 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 database access/business logic/presentation layers), unit test coverage for critical database operations, 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 Vue frontend 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 visualization of database schema and query results. Deduct 3 points for cluttered database navigation elements, 5 points for poorly formatted query results display, and 5 points for inconsistent form design across different database operations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the Vue frontend implements responsive interactions: 1) Query execution feedback with loading indicators ≤ 100ms 2) Smooth database switching without page reloads 3) Efficient large result set pagination and virtualization. Deduct 5 points for operations without visual feedback, 3 points for noticeable lag when switching between database types, and 5 points for poor handling of large query results. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}

package/library/management_systems-frontend_backend_platforms/deepseek-generate-react-project-from-design.json

@@ -0,0 +1,68 @@
+{
+  "index": 957,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure that the code you generate is executable for demonstration purposes. How can one use DeepSeek to generate a React project based on design specifications?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "DeepSeek integration completeness",
+      "description": "Evaluate whether the code provides a comprehensive approach to integrate DeepSeek for React project generation, including proper API initialization, authentication handling, and response parsing. Check if the implementation includes error handling for API limitations and rate limits. Score 0 if there's no clear DeepSeek integration, 5 for basic implementation without error handling, and 10 for robust integration with complete error recovery mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Design specification translation accuracy",
+      "description": "Assess how effectively the implementation converts design specifications into structured prompts for DeepSeek. Check if it includes methods for parsing various specification formats (Figma links, JSON, text descriptions) and translating them into detailed AI instructions. Deduct 3 points if it only handles one type of specification format, 5 points if the translation lacks detail preservation, and 8 points if there's no validation mechanism to ensure specification accuracy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "React component generation quality",
+      "description": "Review the quality of React components generated through DeepSeek. Examine if the implementation produces modern React practices (hooks, functional components), follows component composition patterns, and maintains proper prop typing. Check for state management integration options. Deduct 3 points if generated components use outdated patterns, 5 points if component architecture is flat without composition, and 5 points if there's no TypeScript/PropTypes support. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Design-to-code pipeline completeness",
+      "description": "Evaluate the end-to-end pipeline from design specification to finished React project. Check if the implementation includes steps for project scaffolding, component generation, styling integration, routing setup, and build configuration. The pipeline should include intermediate validation steps and allow for iterative refinement. Deduct 5 points if the pipeline is linear without feedback loops, and 5 points if it doesn't include build/deployment configuration. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Code robustness",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as API failures, timeout issues, malformed design specifications, 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": "Innovative features",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Interactive design preview before generation 2. Intelligent component naming based on functionality 3. Automatic accessibility compliance checks). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Code redundancy assessment",
+      "description": "Strictly check three types of redundancy: 1. Redundant API calls to DeepSeek that could be batched or cached 2. Unnecessary abstraction layers between the application and DeepSeek 3. Inefficient code generation patterns that produce bloated React components. 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": "Engineering quality",
+      "description": "Review modular design (such as separating DeepSeek API interactions/React generation logic/user interface), 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": "User interface quality",
+      "description": "Evaluate whether any UI for interacting with the DeepSeek-powered generator 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": "Interaction fluidity",
+      "description": "Judge whether the process of using DeepSeek to generate React projects offers fluid interaction: 1) Processing feedback for long-running operations 2) Incremental component previewing during generation 3) Clear progress indicators for multi-step processes. Deduct 5 points for operations without progress indicators, 3 points for UI freezes during API calls, and 5 points for confusing navigation between steps. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}

package/library/management_systems-frontend_backend_platforms/design-draft-review-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 585,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for demonstration. Implement a design draft review system that supports Sketch/PSD file preview, allows reviewers to select areas on design drawings and add comments, provides multi-version comparison views (with left-right sliding comparison), and automatically generates a summary document of modification suggestions (sorted by number of comments).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the file upload and preview system fully implemented?",
+      "description": "Review whether the code implements proper file uploading for Sketch/PSD files, handles file validation, and converts these design files into viewable formats (SVG/PNG) on the web interface. Check if there's progress indication during upload/conversion. Score 0 if there's no file handling, 5 if only basic upload exists without proper preview, and 10 if the system handles both Sketch and PSD files with proper preview rendering.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the area selection and commenting feature properly implemented?",
+      "description": "Evaluate if the implementation allows users to select specific areas of design drawings (rectangular/polygon/freeform selection), attach comments to these selections, and display them appropriately. Check if selection coordinates are properly stored and if selected areas remain visible when hovering over corresponding comments. Deduct 5 points if only rectangular selection is available, 3 points if selection coordinates aren't preserved across sessions, and 2 points if there's no visual indication of commented areas. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the multi-version comparison view functioning correctly?",
+      "description": "Check if the system can load and display different versions of the same design for comparison (side-by-side or overlay). Verify if the left-right sliding comparison works smoothly with synchronized zooming/panning. Test if differences between versions are highlighted or can be automatically detected. Deduct 5 points if comparison view lacks synchronization between versions, 3 points if zooming causes misalignment, and 5 points if the slider mechanism is jerky or imprecise. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the automatic summary generation work as expected?",
+      "description": "Verify if the system aggregates comments and generates a structured summary document. Check if comments are properly categorized, sorted by frequency/importance, and if the summary includes screenshots of commented areas. Evaluate if the summary can be exported in common formats (PDF, DOC). Deduct 5 points if sorting by comment count doesn't work, 3 points if there's no categorization feature, and 5 points if export functionality is missing or broken. 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 corrupted design files, browser compatibility issues, large file uploads, concurrent edits, etc.) and provide friendly error prompts or recovery mechanisms. Check if there's proper validation for all user inputs and API responses. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no 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-powered design suggestions 2. Automatic design consistency checking 3. User activity heat maps showing most commented areas 4. Voice comments with transcription). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to add the same type of comment) 2. Function modules unrelated to design review (e.g., a built-in chat system unrelated to commenting) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow down the review process). 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 file handling/UI/comment management layers), unit test coverage, and build process automation. Check if rendering optimization is implemented for large design files. 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). Check if the interface maintains clarity while displaying complex design assets. 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. Test specifically for responsiveness during design asset manipulation (zooming, panning, selecting). 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/device-maintenance-reminder-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 621,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable and displayable. ======== ROLE ========\nYou are an experienced code expert. I will provide you with a software development requirement description, and you need to generate project code based on these requirements. Strictly follow the rules to help users generate complete project code with simple and easy-to-understand comments, without outputting anything else.\n\n======== OUTPUT RULES ========\n1. You should always generate complete, runnable project code, and ensure the project is fully executable\n2. Ensure all code files you output are complete, do not omit any code\n3. Before the 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 ========\nCreate a device maintenance reminder system where maintenance cycles must be set when registering devices (based on operating hours/calendar days). The homepage should use colors to distinguish device maintenance status (green-normal, yellow-due within 7 days, red-overdue). Clicking on a device should display maintenance history records and allow adding new maintenance records (including maintenance personnel and consumables used).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the device registration system with maintenance cycle setting fully implemented?",
+      "description": "Review whether the code implements a complete device registration system allowing for setting maintenance cycles in both operating hours and calendar days. Check if it includes input validation for mandatory fields, device categorization, and handles edge cases (like negative cycle values or extremely large numbers). Score 0 if core registration functionality is missing, 5 if basic registration exists but lacks proper cycle configuration, and 10 if the registration system is comprehensive with validation and flexible cycle setting options.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the color-coded device status visualization properly implemented?",
+      "description": "Evaluate whether the status visualization accurately implements the three-tier color system (green-normal, yellow-due within 7 days, red-overdue). Verify if the color states update dynamically based on real-time calculations rather than fixed values. Check if the visualization is accessible (includes text indicators alongside colors) and handles edge cases like devices with multiple maintenance types. Deduct 5 points if color logic is inconsistent, 3 points if the visualization isn't responsive across different screen sizes.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the device detail view with maintenance history records complete?",
+      "description": "Check whether clicking on a device properly displays comprehensive maintenance history with chronological ordering and filtering options. Verify if the history view includes all relevant information (maintenance dates, personnel, actions taken, consumables used). Assess whether pagination or lazy loading is implemented for devices with extensive history. Score 0 if history viewing is not implemented, 5 if basic history exists but lacks filtering/sorting, and 10 if the history view is comprehensive and user-friendly.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the maintenance record addition functionality properly implemented?",
+      "description": "Review the new maintenance record addition functionality including form validation, personnel selection, consumables tracking, and automatic date stamping. Verify if the system recalculates next maintenance dates after new records are added. Check if maintenance personnel authentication/authorization is implemented. Deduct 5 points if form validation is missing, 3 points if there's no confirmation dialog before submission, and 2 points if consumables tracking is incomplete.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruption, user input errors, database connection issues, 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. Predictive maintenance suggestions based on history 2. Consumables inventory management integration 3. Mobile-friendly notifications for upcoming maintenance). 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 date calculation methods coexisting) 2. Function modules unrelated to maintenance tracking (e.g., a built-in weather widget) 3. Fancy effects that affect performance (e.g., unnecessary animations on the device list). 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 device logic/maintenance tracking/UI 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 beyond the required status 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 when switching between device list and maintenance details. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast switching between views, and 5 points for hard-to-find maintenance addition buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}