@getollie/cli 0.0.1

package/library/management_systems-frontend_backend_platforms/parcel-collection-point-management-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 462,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code in your demonstration. Implement a package management system for a parcel collection point where recipients can input their collection code on a front-end page to query package information (including tracking number, courier company, and collection status). Collection point staff (username: worker, password: express123) can log into the backend to add, delete and modify package information, and process collection operations.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the recipient search/query functionality fully implemented?",
+      "description": "Review whether the code implements a complete package search system using collection codes. Check if the query interface is intuitive, provides real-time feedback, and includes error handling for invalid codes. Score 0 if the core search functionality is missing, 5 if basic lookup is implemented but lacks validation or proper error handling, and 10 if the implementation includes comprehensive validation, error states, and clear user feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the staff authentication system properly implemented?",
+      "description": "Evaluate whether the login system for staff (username: worker, password: express123) includes proper authentication mechanisms. Check for token-based authentication, session management, password hashing, CSRF protection, and secure storage. Deduct 3 points if passwords are stored in plain text, 3 points if there's no session timeout, and 4 points if authentication can be easily bypassed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the package CRUD functionality complete for staff?",
+      "description": "Assess whether staff can perform all required operations (Create, Read, Update, Delete) on package information. Check for form validation, proper data structure for package information (tracking number, courier company, collection status), and intuitive interfaces for each operation. Deduct 3 points for each missing operation, and 2 points if batch operations are not supported when appropriate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the package collection process workflow implemented?",
+      "description": "Review whether the code includes a complete workflow for package collection, including status updates, timestamps for collection, validation of collection codes, and notification mechanisms. Check if the system maintains an audit trail of collections. Deduct 5 points if status updates aren't atomic operations, 3 points if there's no collection timestamp recording, and 2 points if there's no collection confirmation step. 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 invalid inputs, network interruptions, concurrent operations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time package tracking integration 2. SMS/email notifications to recipients 3. QR code generation for contactless collection). 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 search packages) 2. Function modules unrelated to package management (e.g., built-in games for users waiting) 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 backend/frontend, using MVC or similar patterns), 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": "easy"
+}

package/library/management_systems-frontend_backend_platforms/performance-evaluation-system-with-quarterly-bonuses.json

@@ -0,0 +1,68 @@
+{
+  "index": 840,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional responses. Try to ensure the generated code is executable for demonstration. I want to create a program for performance evaluation that allows users to view evaluation criteria categories with their serial numbers and names, where evaluatees can fill in bonus items and self-assess their scores. The data should then be exported or uploaded directly to evaluators for verification and scoring. Evaluations occur quarterly, and the system should be able to display bonus items from previous quarters as needed, with automatic flagging of repeated work content that receives multiple bonuses. The system should display current quarter scores and rankings, as well as cumulative annual scores and rankings. Please recommend a suitable programming language and provide reference code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the evaluation criteria display system fully implemented?",
+      "description": "Review whether the code accurately implements the display of evaluation criteria categories with serial numbers and names. Check if the interface allows users to browse and understand the criteria structure clearly. Score 0 if the criteria display is not implemented, 5 if only basic display is implemented without proper organization, and 10 if the criteria are well-structured with intuitive navigation and visual hierarchy.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the self-assessment functionality completely implemented?",
+      "description": "Evaluate whether the code implements the self-assessment functionality for evaluatees to fill in bonus items and self-assess their scores. Check if users can easily add new bonus items, provide descriptions, and assign self-assessment scores. Deduct 3 points if the interface is not intuitive, 4 points if validation is missing for score ranges, and 5 points if there's no way to save draft assessments. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the system implement data export and submission to evaluators?",
+      "description": "Check whether the system allows for exporting assessment data and/or direct submission to evaluators. The solution should include a secure mechanism for data transfer and verification by evaluators. Deduct 5 points if only one method (export or direct upload) is implemented, 3 points if the data format is not standardized, and 5 points if there's no confirmation mechanism for successful submission. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the historical data view and duplicate bonus detection implemented?",
+      "description": "Evaluate whether the system properly displays bonus items from previous quarters and automatically flags repeated work content that receives multiple bonuses. Check if the historical view allows for easy comparison between quarters. Deduct 5 points if the historical view is missing, 5 points if duplicate detection is not implemented, and 3 points if the flagging mechanism isn't visually clear. 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 invalid input data, network interruptions, concurrent user operations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle 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. Visualization of score trends over time 2. Automated recommendations for improvement based on evaluation patterns 3. Real-time comparative performance metrics with anonymized peer data). 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 scoring systems coexisting) 2. Function modules unrelated to performance evaluation (e.g., built-in games or entertainment features) 3. Fancy effects that affect performance (e.g., unnecessary animations or visualizations). 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/logic/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) 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 data loading, 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/performance-management-system-vue-java-mysql.json

@@ -0,0 +1,68 @@
+{
+  "index": 1628,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration purposes. Please help me create a performance management system based on Vue, which includes: ticket purchasing, pre-sales, performance type inquiries, personal ticket purchase records, and payment methods. The database uses MySQL, the backend uses Java Web, and the frontend uses the Vue framework. Please include detailed code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Vue frontend architecture properly implemented?",
+      "description": "Review whether the code properly implements Vue's component-based architecture, uses Vue Router for navigation, Vuex for state management, and follows Vue's best practices. Check if components are properly organized, reusable, and implement proper props validation. Score 0 if Vue is not used effectively, 5 if basic Vue functionality is present but with architectural issues, and 10 if the implementation follows Vue best practices with proper component lifecycle management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the ticket purchasing flow completely implemented?",
+      "description": "Evaluate whether the code implements all steps in the ticket purchasing flow: browsing events, seat selection, reservation, checkout, and confirmation. Check if the system handles concurrent seat selection, maintains seat reservation status, and implements timeout for reserved but unpurchased tickets. Deduct 3 points if seat visualization is missing, 3 points if reservation timeout is not implemented, and 4 points if concurrent booking issues are not addressed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are pre-sales and performance type inquiries properly implemented?",
+      "description": "Check if the pre-sales module includes announcement functionality, countdown timers, reminder settings, and waiting list management. For performance inquiries, verify if filtering by types, dates, venues, price ranges, and search functionality are implemented. Deduct 3 points if pre-sales lack notifications, 3 points if waiting lists are not implemented, and 3 points if performance filtering is limited. 10 points if fully implemented with user-friendly interfaces.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the personal ticket management and payment system complete?",
+      "description": "Evaluate whether personal ticket records include purchase history, active tickets, e-ticket display with QR codes, and refund/exchange capabilities. For payments, check integration with multiple payment gateways, secure transaction handling, and payment status tracking. Deduct 3 points if e-tickets lack proper display, 3 points if payment gateway integration is incomplete, and 3 points if refund processes are 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 failures during payment, session timeouts, concurrent transactions, database connection 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. Interactive seat selection with real-time availability updates 2. Virtual venue tour before purchase 3. Social sharing with personalized ticket images 4. Event recommendations based on purchase history). Add 2.5 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 payment processing methods that do the same thing) 2. Function modules unrelated to performance management (e.g., a built-in game while waiting) 3. Fancy effects that affect performance (e.g., heavy animations on ticket pages). 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, UI components, and business logic), test coverage, and build process automation. Check if proper API abstraction layers and data models are used. Deduct 5 points if global state is misused; deduct 3 points if the code duplication rate is too high (over 30%); deduct 3 points if the build process is not automated; deduct 2 points if security measures for database access are inadequate. 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 suitable for an entertainment platform (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) 4) Consistent design language across all pages. 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 4) Proper loading states during API calls. Deduct 3 points for each operation without feedback, 2 points for jarring transitions between pages, 3 points for lack of loading indicators, and 3 points for confusing navigation paths. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Online Shopping",
+  "difficulty": "hard"
+}

package/library/management_systems-frontend_backend_platforms/personal-finance-management-tool-with-budgeting-and-import.json

@@ -0,0 +1,68 @@
+{
+  "index": 561,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Design a personal finance management tool where users can record daily income and expenses, set expense categories, view monthly financial statistics and trend charts. Support importing bank statement CSV files with automatic transaction categorization. Provide a budget setting feature that alerts users when certain expenses approach or exceed their budget. Data should be encrypted and stored locally.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core financial record functionality fully implemented?",
+      "description": "Review whether the code accurately implements income and expense recording capabilities, with proper data structures for financial entries (date, amount, category, description). Score 0 if the core data entry mechanisms are missing, 5 if basic record creation exists but lacks editing/deletion capabilities, and 10 if CRUD operations for financial records are fully implemented with data validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the category management system properly designed?",
+      "description": "Evaluate if the code implements customizable expense/income categories with hierarchical structures (parent/sub-categories). Check for the ability to create, edit, merge, and delete categories while preserving historical data integrity. Score 3 points for basic category creation, 7 points if category management includes data validation and prevents orphaned transactions, and 10 points if it also includes default categories and smart category suggestions.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the monthly financial statistics and visualization charts properly implemented?",
+      "description": "Check whether the code generates accurate financial summaries and uses appropriate chart types (pie, bar, line) for different metrics. Charts should be interactive, responsive, and include proper legends and labels. Deduct 5 points if charts lack filtering capabilities, 3 points if they're not interactive, and 3 points if they don't handle edge cases like no data or extreme values. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is CSV import functionality with automatic categorization implemented?",
+      "description": "Assess whether the code can parse different CSV formats from common banks, match transaction descriptions to appropriate categories using pattern matching or machine learning, and handle edge cases like duplicate entries or format errors. Deduct 3 points if only a single bank format is supported, 5 points if automatic categorization isn't implemented, and 5 points if there's no error handling for malformed data. 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 invalid input data, format errors, duplicate entries, 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 analysis for future spending 2. OCR receipt scanning for automatic entry 3. Integration with financial APIs for real-time data). 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 calculate the same financial metrics) 2. Function modules unrelated to personal finance (e.g., a built-in currency converter when the app is single-currency) 3. Fancy effects that affect performance (e.g., excessive animations in data visualizations). 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 models, business logic, visualization layers), encryption implementation for financial data, and local storage architecture. 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 data encryption is not implemented. 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 suitable for financial data (with consistent accent colors for income/expense) 2) Proper layout spacing (financial information properly grouped with clear visual hierarchy) 3) Professional font system (numerals using monospace fonts, proper currency formatting). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic data presentation. 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) Budget alerts appear within 100ms of value change 2) Smooth transitions between different financial views 3) Clear visual feedback for financial data entry and confirmation. Deduct 5 points for each operation without feedback, 3 points for jarring transitions between data views, and 5 points for hard-to-find key function buttons like 'add transaction'. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}

package/library/management_systems-frontend_backend_platforms/personal-knowledge-base-management-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 864,
+  "question": "You are a code expert. Please utilize your professional knowledge to generate accurate and professional responses. Be sure to provide executable and demonstrable code whenever possible. As a technical professional, write a complete version of a knowledge base management system for personal use.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core knowledge base storage and retrieval system fully implemented?",
+      "description": "Review whether the code implements a proper data structure for knowledge storage (e.g., relational database, document storage, graph database) with CRUD operations. Check if the code includes proper indexing for efficient knowledge retrieval and supports both structured and unstructured data. Score 0 if core storage functionality is missing, 5 if basic storage is implemented but lacks advanced retrieval, and 10 if the system includes comprehensive storage with efficient indexing and search capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the knowledge organization and categorization system properly designed?",
+      "description": "Evaluate whether the code implements hierarchical categorization, tagging system, and relationship mapping between knowledge items. Check if it supports metadata management, custom taxonomies, and dynamic reorganization of knowledge. Deduct 5 points if the system doesn't support flexible categorization, 3 points if it lacks relationship management, and 2 points if it doesn't handle metadata effectively. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the search and filtering functionality comprehensive?",
+      "description": "Assess whether the system implements full-text search with ranking algorithms, supports advanced filtering options (date range, category, tags, etc.), and includes features like fuzzy search, synonym support, and search history. Deduct 5 points if only basic string matching is implemented, 3 points if advanced search options are missing, and 2 points if the search lacks performance optimization. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the system include user-friendly content creation and editing tools?",
+      "description": "Check whether the code provides a rich text editor with formatting options, supports multimedia content embedding, offers version history and rollback functionality, and includes draft saving. Score 0 if editing capabilities are minimal, 5 if basic editing is supported without versioning or media handling, and 10 if comprehensive editing tools with versioning and media support are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, database connection failures, concurrent edits, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include input validation, error handling, and data integrity checks. Give 10 points if robustness is comprehensive, 5 points if basic error handling exists, and 0 points if exceptions are not handled properly.",
+      "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 content suggestions 2. Knowledge graph visualization 3. Spaced repetition learning system 4. Automatic content summarization). 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 engines coexisting) 2. Function modules unrelated to knowledge 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 modular design (such as separating data/business logic/view 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 scrolling or searching, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}

package/library/management_systems-frontend_backend_platforms/personal-novel-website-with-mysql.json

@@ -0,0 +1,68 @@
+{
+  "index": 281,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure the code you generate is executable. I need a website with a MySQL database to store novels, novel categories, and user information. The front-end code should provide functionality for uploading and downloading novels, user login and registration, novel detail pages and reading interface, novel categorization, reading progress tracking, a personal profile page, and a \"currently reading\" feature. I want a personal novel website exclusively for myself and people I authorize to access.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the complete user authentication system implemented?",
+      "description": "Review whether the code includes comprehensive authentication implementation, covering registration, login, password reset, and authorization management. The system should use secure password hashing (bcrypt/Argon2), implement JWT or session-based authentication, and include role-based access control (admin vs regular users). Score 0 if basic authentication is missing, 5 if only basic functions exist without security measures, and 10 if the implementation includes all security best practices with invitation-only registration as specified.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the novel database structure properly designed with all required relationships?",
+      "description": "Evaluate the MySQL database schema design, checking for proper normalization, relationships between novels, categories, users, and reading progress. The schema should include appropriate indexes, foreign key constraints, and efficient query structures. Deduct 3 points if novels-to-categories uses a basic relationship rather than a many-to-many junction table; deduct 5 points if reading progress tracking lacks timestamp information or book position markers; deduct 3 points if user permission levels aren't granularly defined. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the novel upload and download functionalities complete?",
+      "description": "Check whether the code implements secure file handling for uploads (validate file types, scan for malware, handle large files with chunking), supports multiple formats (EPUB, PDF, TXT), and provides efficient download options. The implementation should include metadata extraction, proper storage path management, and content validation. Deduct 5 points if upload size limitations aren't handled; deduct 3 points if download progress indicators are missing; deduct 5 points if no content validation exists. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the novel reading interface well-designed and feature-complete?",
+      "description": "Assess whether the reading interface includes essential features: text size adjustment, theme switching (light/dark mode), bookmarking, highlighting, auto-scroll options, and progress tracking. The UI should be responsive across device sizes and remember user preferences. Deduct 3 points for each missing core feature; deduct 5 points if the interface doesn't adapt to mobile screens; deduct 3 points if reading position isn't automatically saved. 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 database connection failures, invalid uploads, concurrent user edits, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should implement proper error handling, input validation, and graceful degradation. Give 10 points for comprehensive error handling with user-friendly messages, 5 points if basic error handling exists but edge cases are missed, and 0 points if exceptions aren't 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. AI-powered reading time estimations 2. Automatic chapter detection and navigation 3. Reading statistics dashboard 4. Social sharing options with access control). 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 progress tracking methods coexisting) 2. Function modules unrelated to novel management (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., unnecessary 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 (such as separating data access/business logic/view 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/pharmacy-mini-program-user-order-page.json

@@ -0,0 +1,68 @@
+{
+  "index": 306,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code where possible. Please help me create a frontend page for a pharmacy store mini-program, which should include user information, a login button, and four order status categories (unpaid, in progress, to be received, and completed). The function menu should include history records, favorites, my customer service, my orders, shipping address, and settings.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the user authentication system properly implemented?",
+      "description": "Review whether the code implements a complete user authentication flow including login button functionality, session management, and secure token storage. Check if there's proper handling of authentication states (logged in/out) and user information display. Score 0 if no authentication logic exists, 5 if basic login UI is present without functionality, 10 if a complete secure authentication system is implemented with proper state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the four order status categories fully implemented and visually distinct?",
+      "description": "Verify that all four required order status categories (unpaid, in progress, to be received, and completed) are implemented with clear visual differentiation. Check if the code includes state transitions between categories and proper data binding. Deduct 3 points if any category is missing, 2 points if visual distinction is poor, and 2 points if state transitions are not implemented. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the function menu complete with all required features?",
+      "description": "Confirm that all six specified menu items (history records, favorites, my customer service, my orders, shipping address, and settings) are properly implemented with navigation logic. Each missing feature deducts 1.5 points. Check if each menu item has appropriate icons and leads to the correct functionality. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the pharmacy store context appropriately reflected in the design?",
+      "description": "Evaluate whether the implementation correctly reflects the pharmacy context through appropriate terminology, icons, color schemes (medical blues/greens), and pharmacy-specific features like prescription management or medication categories. Deduct 3 points if the design is generic without pharmacy-specific elements, 3 points if inappropriate terminology is used, and 4 points if the context is completely mismatched. 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, authentication failures, empty data states, 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. Medication reminder functionality 2. Prescription scanning capability 3. Health tips integration). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple user profile sections) 2. Function modules unrelated to a pharmacy mini-program (e.g., gaming features) 3. Fancy effects that affect performance (e.g., heavy animations on critical paths). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI components/data services/state management), code reusability for similar elements (like order cards), and proper naming conventions. 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 clear project structure. 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": "easy"
+}

package/library/management_systems-frontend_backend_platforms/phone-program-sort-names-statistics.json

@@ -0,0 +1,68 @@
+{
+  "index": 1757,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code generated is executable for demonstration purposes. Could you write a small program for my phone that can sort 40 names, which can be shared with around 40 people, then consolidate the data and provide statistics?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the sorting functionality fully implemented?",
+      "description": "Review whether the code accurately implements the name sorting mechanism, with proper algorithm selection for efficiency (like quicksort, mergesort) and support for multiple sorting criteria (alphabetical, length, custom order). Score 0 if sorting is not implemented, 5 if only basic alphabetical sorting is available, and 10 if multiple flexible sorting options with proper complexity analysis are provided.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the data input mechanism user-friendly for mobile devices?",
+      "description": "Evaluate whether the input method is optimized for mobile use, with features like autocomplete, input validation, bulk import options (e.g., from contacts, CSV), and proper keyboard type selection. Check for responsive design that works across different screen sizes. Deduct 5 points if text input fields are not mobile-optimized, and 3 points if there's no input validation. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the sharing functionality work effectively for 40 people?",
+      "description": "Check if the code implements practical sharing methods like QR codes, shareable links, email integration, or export options. Verify that sharing preserves data integrity and works without requiring special apps for recipients. Deduct 5 points if sharing requires manual copying, 5 points if there's no confirmation mechanism, and 3 points if privacy controls are absent. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the data consolidation and statistics generation complete?",
+      "description": "Assess whether the program can effectively merge data from multiple sources, handle duplicates, and generate meaningful statistics (e.g., frequency distributions, grouping by categories, visualization of trends). Check for data validation mechanisms and conflict resolution. Deduct 5 points if basic aggregation is missing, 3 points if statistical analysis is limited to counts only, and 5 points if there's no visualization. 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 issues when sharing, duplicate names, special characters in names, empty submissions) 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. Name pronunciation audio recording 2. Auto-grouping algorithms 3. Interactive data visualization of sorting results). 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 sorting implementations without clear purpose) 2. Function modules unrelated to name sorting and statistics (e.g., a built-in game) 3. Fancy effects that affect performance on mobile devices (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), unit test coverage, and offline functionality. 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 application doesn't work offline. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional mobile design standards?",
+      "description": "Evaluate whether the overall design follows modern mobile design principles: 1) Harmonious color matching suitable for mobile screens (no more than 3 primary colors) 2) Thumb-friendly layout with key interactions in reachable zones 3) Professional typography system (body font size ≥ 16px for readability). Deduct 3 points for each hard-to-tap element, 5 points for poor contrast ratios, and 5 points for layouts requiring horizontal scrolling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive on mobile devices?",
+      "description": "Judge whether the dynamic effects are optimized for mobile: 1) Touch feedback delay ≤ 100ms 2) Smooth scrolling through potentially long name lists 3) Clear visual indicators of sorting/processing status. Deduct 5 points for each interaction lacking tactile/visual feedback, 3 points for janky animations, and 5 points for any operation taking more than 2 seconds without a progress indicator. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}