@getollie/cli 0.0.1

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

@@ -0,0 +1,68 @@
+{
+  "index": 810,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable and can be demonstrated. I've just created a project, but it has only one typical template that isn't helpful for me. I need to write a small program that allows for ordering food like in a restaurant.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the restaurant order system's core functionality fully implemented?",
+      "description": "Review whether the code implements the essential features of a food ordering system including menu display, item selection, cart management, and order submission. Score 0 if these core interactions are missing, 5 if only basic item selection is implemented, and 10 if the complete ordering flow is present with proper state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the menu data structure and display properly designed?",
+      "description": "Evaluate whether the menu is structured logically (e.g., with categories, item descriptions, prices, and images) and displayed in an easily navigable format. Check if items can be filtered or searched. Deduct 5 points if the menu is just a flat list without categories, 3 points if item details are incomplete, and 2 points if no search/filter functionality exists. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the cart and order management system comprehensive?",
+      "description": "Check if the system allows adding/removing items from the cart, changing quantities, displaying subtotals and totals, and applying special requests or customizations. Verify that the order confirmation process includes a review step. Deduct 3 points if quantity modification isn't supported, 3 points if no order summary is shown, and 4 points if item customization is not possible. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a user authentication and order history feature?",
+      "description": "Assess whether the system includes user accounts, login functionality, and the ability to view past orders. Check if users can reorder previous meals and if guest ordering is supported as an alternative. Deduct 5 points if user authentication is missing, 3 points if order history isn't implemented, and 2 points if no guest ordering option exists. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common edge cases (such as empty cart checkout attempts, invalid input values, network errors when fetching menu data, etc.) and provide friendly error messages. Code with strong error handling should receive 10 points. If only basic validation exists, give 5 points, and if no error handling is implemented, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time order status tracking 2. Dietary preference filters 3. Estimated preparation time calculator 4. Meal recommendation system based on past orders). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple cart management logics) 2. Function modules unrelated to food ordering (e.g., a built-in game while waiting) 3. Fancy effects that affect performance (e.g., excessive animations when adding items to cart). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/state management/data handling), component reusability, and code organization. Deduct 5 points if global state is poorly managed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear project structure or naming conventions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast scrolling through menu items, and 5 points for hard-to-find key function buttons like 'Add to Cart' or 'Checkout'. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "easy"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 1666,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration purposes. Help design a form management system, similar to those in low-code platforms.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core form builder functionality properly implemented?",
+      "description": "Check if the code includes essential form components (inputs, checkboxes, selects, etc.) with proper data binding and validation. Form elements should have proper attributes including labels, placeholders, and accessible markup. Score 0 if the form builder core is missing, 5 if only basic elements are included, and 10 if a comprehensive component library with validation is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is drag-and-drop functionality for form construction implemented?",
+      "description": "Evaluate whether the system includes intuitive drag-and-drop functionality for arranging form elements. This should include element positioning, nesting capabilities, and grid/layout management. Deduct 5 points if drag-and-drop is missing, 3 points if it's rudimentary without proper visual feedback. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is form data management and submission handling implemented?",
+      "description": "Assess the implementation of form data management including state management, data validation, conditional logic, and submission handling. Look for features like form state persistence, API integration options, and error handling during submission. Deduct 5 points if validation is missing, 3 points if conditional logic is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are form templates and saving/loading mechanisms provided?",
+      "description": "Check if the system includes template management functionalities such as saving forms as templates, loading existing templates, and importing/exporting form configurations (JSON/XML). Deduct 5 points if export/import is missing, 3 points if there's no template library. Give 10 points if fully implemented with version control.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid form configurations, network failures during submission, browser compatibility issues) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-assisted form creation 2. Accessibility checker with recommendations 3. Multi-device preview mode). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar form components (e.g., multiple text input implementations) 2. Function modules unrelated to form management (e.g., unnecessary image galleries) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating form model/view/controller layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}

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

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

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

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

package/library/management_systems-frontend_backend_platforms/frontend-deployment-dashboard-with-monitoring.json

@@ -0,0 +1,68 @@
+{
+  "index": 612,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable whenever possible. Build an automated deployment dashboard that displays deployment status, version history, build logs and other information for frontend projects, with support for manually triggering builds and monitoring automated deployment workflows.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the deployment status monitoring system fully implemented?",
+      "description": "Review whether the code accurately implements real-time deployment status tracking through REST APIs or WebSocket connections, including pipeline stages (building, testing, deploying), progress indicators, and status change notifications. Score 0 if core status monitoring is not implemented, 5 if only basic status display is available, and 10 if comprehensive multi-stage status tracking with real-time updates is fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the version history and build logs management implemented?",
+      "description": "Check whether the implementation includes complete version history tracking with commit information, deployment timestamps, and searchable/filterable build logs with syntax highlighting. Requires pagination for large datasets and log streaming capabilities. Deduct 5 points if log search functionality is missing, and 3 points if version comparison features are not handled. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the manual build trigger mechanism designed with proper workflow integration?",
+      "description": "Evaluate whether the manual trigger system includes parameter input validation, branch/tag selection, environment targeting, and proper authentication/authorization. Must integrate with CI/CD platforms (Jenkins, GitLab CI, GitHub Actions) with proper API error handling. Deduct 5 points if parameter validation is insufficient. Check whether rollback functionality is implemented for failed deployments. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the automated workflow monitoring and alerting system constructed?",
+      "description": "Check whether the code includes comprehensive workflow monitoring with webhook integration, failure detection, notification systems (email, Slack, etc.), and deployment metrics tracking. Deduct 5 points if automated alert configuration is not implemented, and 3 points if performance metrics collection is missing. Give 10 points if fully implemented with customizable alert rules.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as API timeouts, authentication failures, network interruptions, malformed CI/CD responses, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include retry logic, graceful degradation, and proper error boundaries, 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 deployment experience (e.g., 1. Visual deployment pipeline diagrams 2. Performance impact analysis between versions 3. Automated rollback triggers based on error rates 4. Integration with monitoring tools like Grafana). 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 API polling mechanisms coexisting) 2. Function modules unrelated to deployment management (e.g., built-in code editor) 3. Excessive UI animations that affect dashboard performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core deployment 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 API services/state management/UI components), TypeScript usage, error handling patterns, and configuration management. Deduct 5 points if API credentials are hardcoded or environment configuration is missing; deduct 5 points if the code lacks proper async/await error handling; deduct 5 points if no build optimization or bundling strategy is implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional dashboard design standards?",
+      "description": "Evaluate whether the dashboard design follows enterprise UI principles: 1) Information hierarchy with proper data visualization (charts, progress bars, status indicators) 2) Consistent spacing and grid system 3) Professional color coding for status states (green/red/yellow for success/error/pending). Deduct 3 points for each cluttered data presentation, 5 points for poor color contrast affecting readability, and 5 points for inconsistent component styling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the real-time data interaction smooth and responsive?",
+      "description": "Judge whether the dashboard updates conform to real-time monitoring standards: 1) Status updates with minimal delay (≤ 2 seconds) 2) Smooth data refresh without UI flickering 3) Proper loading states and skeleton screens during data fetching 4) Efficient WebSocket or polling implementation. Deduct 5 points for each delayed status update, 3 points for UI jumping during refreshes, and 5 points for missing loading indicators on critical actions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}

package/library/management_systems-frontend_backend_platforms/frontend-gas-management-system-solution.json

@@ -0,0 +1,68 @@
+{
+  "index": 277,
+  "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. Create a front-end gas comprehensive management system solution using Vite, Vue 3, TypeScript, Pinia, Axios, Element Plus, OpenLayers, Tianditu (Chinese map service), and Tailwind CSS.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core gas management system functionality implemented?",
+      "description": "Review whether the code implements essential gas management features including gas source tracking, pipeline management, leak detection, and monitoring dashboards. Score 0 if core features are missing, 5 if basic features are implemented without integration, and 10 if all essential features are fully integrated with real-time data visualization.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the OpenLayers map integration with Tianditu properly implemented?",
+      "description": "Evaluate the integration of OpenLayers with Tianditu map service, including proper API key usage, coordinate system configuration (CGCS2000), layer management, and custom overlay implementation for gas infrastructure. Deduct 3 points if map initialization fails, 3 points for incorrect projection setup, and 4 points if custom gas infrastructure overlays are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the Vue 3 + TypeScript implementation properly utilizing composition API and type safety?",
+      "description": "Check if the code leverages Vue 3's Composition API with proper TypeScript interfaces/types for all components, stores, and services. Score 0 if TypeScript is barely used, 5 if basic typing exists but with 'any' types, and 10 if comprehensive type definitions are present with proper interfaces for all data structures and strict typing throughout the application.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is Pinia used effectively for state management with proper store design?",
+      "description": "Assess whether Pinia stores are properly organized following domain-driven design principles (e.g., separate stores for map state, gas sources, user info, etc.), include proper actions/getters, and implement persistence where needed. Deduct 3 points for global state pollution, 3 points for missing TypeScript interfaces, and 4 points if stores don't handle loading states or errors properly. 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, map loading errors, invalid user inputs, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include error boundaries, fallback UI components, and comprehensive input validation. Give 10 points for comprehensive error handling, 5 points for average implementation, and 0 points if exceptions are not 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. Real-time gas leak prediction algorithms 2. AR visualization for field technicians 3. Automated reporting with data visualization 4. Intelligent alerts with severity classification). 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 map instances for the same view) 2. Function modules unrelated to gas management (e.g., unnecessary social features) 3. Fancy effects that affect performance (e.g., excessive animations on critical monitoring 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 API/services/components/stores), unit test coverage with Vitest or Jest, proper Vite configuration, and build process automation. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not optimized for production. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the Element Plus implementation and Tailwind CSS usage follow modern design principles: 1) Consistent theme customization (no default Element Plus theme mixed with custom styles) 2) Proper responsive layout using Tailwind's grid system 3) Professional data visualization components with appropriate color schemes for gas monitoring. Deduct 3 points for inconsistent component styling, 5 points for non-responsive layouts, and 5 points for poor data visualization design. 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) Map interactions respond within 100ms 2) Data filtering and searching provides immediate visual feedback 3) Critical alerts have appropriate animation attention mechanisms. Deduct 5 points for each operation without feedback, 3 points for laggy map interactions, and 5 points for missing loading states during data fetching operations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}

package/library/management_systems-frontend_backend_platforms/frontend-login-system-with-registration-and-admin.json

@@ -0,0 +1,68 @@
+{
+  "index": 290,
+  "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. Use VSCode to help me create a frontend login system that includes user registration, user login, and administrator login.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the user registration system properly implemented?",
+      "description": "Check if the registration form includes essential fields (username, email, password, confirm password), client-side validation (email format, password strength, matching passwords), feedback mechanisms for validation errors, and proper handling of form submission. Score 0 if registration functionality is missing, 5 if basic form exists but lacks validation, 10 if fully implemented with comprehensive validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the user login functionality complete?",
+      "description": "Evaluate if the login form includes necessary fields (username/email, password), implements authentication logic, provides proper error handling for failed login attempts, and includes 'remember me' and 'forgot password' options. Deduct 3 points if password masking/visibility toggle is missing, 3 points if login error messages are not user-friendly, 5 points if no session management is implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the administrator login functionality properly distinguished?",
+      "description": "Assess whether the admin login is properly separated from regular user login, includes additional security measures (such as two-factor authentication or CAPTCHA), and provides appropriate access controls to admin functionalities. Deduct 5 points if admin and user logins are not clearly differentiated, 3 points if no additional security is implemented for admin access, 5 points if there's no proper access control validation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the frontend-backend integration approach well-designed?",
+      "description": "Check if the code includes clear API endpoints for authentication operations, proper data transmission methods (forms/fetch/axios), response handling, and token-based authentication implementation. Deduct 3 points if API calls are not properly structured, 5 points if no token-based authentication is implemented, 3 points if error handling for API failures is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network errors, invalid inputs, session timeouts, 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. Progressive UI revealing complexity as needed 2. Social login integration 3. Passwordless login options 4. Biometric authentication 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 validation logics coexisting) 2. Function modules unrelated to authentication (e.g., unnecessary dashboard elements) 3. Fancy effects that affect performance (e.g., excessive animations in login flow). 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 authentication logic/UI components/API services), code reusability, naming conventions, and proper comments. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation of concerns. 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 (consistent input sizes, aligned labels). Deduct 3 points for each misaligned form element, 5 points for inconsistent visual styling between forms, and 5 points for poor mobile responsiveness. 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) Form submission feedback within 100ms 2) Smooth transitions between registration and login forms 3) Clear visual indicators of validation states. Deduct 5 points for forms without loading states during submission, 3 points for jarring transitions between authentication steps, and 5 points for validation feedback that appears with significant delay. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}

package/library/management_systems-frontend_backend_platforms/functional-prototype-from-interface-config.json

@@ -0,0 +1,68 @@
+{
+  "index": 1311,
+  "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 display. Help me generate a functional prototype according to the interface configuration content.\n\nFirst, select a menu for page configuration. Step one is to choose a layout template to determine the page layout and which specific components to include (components include: left tree, query area, tab area, button area, list area). Step two is to configure the basic information of the menu, such as whether to enable workflow. Step three is to configure the UI of each component - when there is a left tree, configure the left tree first; when there is a tab area, configure the tabs first. Tables and buttons under different tabs may vary. Step four is to implement rule connections - each component supports connecting rules.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the menu page configuration system fully implemented?",
+      "description": "Review whether the code accurately implements the four-step configuration process: layout template selection, basic menu information setup, component UI configuration, and rule connections. Check if all specified components (left tree, query area, tab area, button area, list area) are properly rendered and configurable. Score 0 if core configuration logic is missing, 5 if only basic template selection is implemented, and 10 if all configuration steps are fully functional with proper state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the dynamic component rendering and layout system implemented?",
+      "description": "Evaluate whether the layout template system can dynamically render different component combinations based on user selection. Check if the component positioning, sizing, and responsive behavior work correctly across different templates. Verify that component visibility and arrangement update in real-time during configuration. Deduct 5 points if layout breaks with certain component combinations, and 3 points if responsive behavior is inconsistent. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the component configuration management properly designed?",
+      "description": "Check whether each component (left tree, query area, tab area, button area, list area) has a comprehensive configuration interface with proper validation. Evaluate if the hierarchical configuration logic (left tree first, then tabs, then tables/buttons under tabs) is correctly implemented with dependency management. Deduct 5 points if configuration data structure is poorly designed, and 3 points if component dependencies are not properly handled. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the rule connection system architected and workflow integration provided?",
+      "description": "Assess whether the rule connection mechanism allows meaningful relationships between components with proper validation and conflict resolution. Check if workflow enablement affects the available rule types and component behaviors. Evaluate if rule connections persist correctly and can be visualized/edited. Deduct 5 points if rule validation is missing, and 3 points if workflow integration is superficial. Give 10 points if fully implemented with visual rule mapping.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid configuration data, component loading failures, rule conflicts, 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 configuration experience (e.g., 1. Visual drag-and-drop layout designer 2. Real-time preview with mock data 3. Configuration templates with import/export 4. Undo/redo configuration history). 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 configuration functions (e.g., multiple component property panels) 2. Function modules unrelated to page configuration (e.g., built-in data analysis tools) 3. Fancy effects that affect configuration performance (e.g., heavy animations during component rendering). Deduct 3 points for each redundancy found, and directly deduct 10 points if core configuration 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 configuration logic/component rendering/state management), component reusability, 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 configuration data serialization is not properly implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the configuration interface follows modern design principles: 1) Harmonious color matching with clear visual hierarchy 2) Proper layout spacing following grid systems 3) Professional typography with clear form labels and help text 4) Consistent iconography and button styles. Deduct 3 points for each crowded configuration panel, 5 points for confusing visual hierarchy, and 5 points for inconsistent UI components. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the configuration interaction smooth and intuitive?",
+      "description": "Judge whether the configuration workflow is intuitive and efficient: 1) Step-by-step guidance with clear progress indication 2) Immediate visual feedback for configuration changes 3) Smooth transitions between configuration steps 4) Context-sensitive help and validation messages. Deduct 5 points for each configuration step without proper feedback, 3 points for confusing navigation between steps, and 5 points for unintuitive component configuration interfaces. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}