@getollie/cli 0.0.5 → 0.2.1

package/library/management_systems-frontend_backend_platforms/html-attendance-system-with-table-import.json

@@ -1,68 +0,0 @@
-{
-  "index": 1575,
-  "question": "You are a code expert, please utilize your professional knowledge to generate accurate and professional responses. Be sure to create executable code that can be demonstrated. Include an HTML format attendance system that can import tables.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core attendance system functionality fully implemented?",
-      "description": "Review whether the code accurately implements the fundamental attendance tracking features, including user registration, check-in/check-out functionality, and attendance records storage. Score 0 if the core functions are missing, 5 if basic attendance tracking is implemented but lacks advanced features, and 10 if all necessary attendance tracking features are comprehensively included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the table import functionality properly implemented?",
-      "description": "Check if the system allows importing attendance data from various table formats (CSV, Excel, etc.). Verify that the import process includes data validation, error handling, and proper display of imported data. Deduct 5 points if the import function is basic without validation, 3 points if only one format is supported, and 2 points if the UI for import is unintuitive. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are data validation and sanitation mechanisms implemented?",
-      "description": "Evaluate whether the code includes proper input validation for all form fields, handles edge cases (like duplicate entries, invalid dates/times), and sanitizes data to prevent XSS attacks. Score 0 if no validation exists, 5 if basic validation is implemented but with security gaps, and 10 if comprehensive validation and sanitation are present.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there an effective data persistence and retrieval mechanism?",
-      "description": "Assess whether the attendance data is properly stored (client-side storage, server interaction, or both) and can be efficiently retrieved for reporting and analysis. Check if data persistence handles browser refreshes and includes backup mechanisms. Deduct 5 points for poor data structure design and 3 points if data retrieval is inefficient. 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 data input, failed imports, network issues, browser compatibility) 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 attendance analytics 2. Automatic absence notifications 3. Customizable reporting 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 ways to import the same data format) 2. Function modules unrelated to attendance tracking (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., unnecessary animations for basic operations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating data/UI/import-export layers), code organization, and maintainability. 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 code lacks comments or documentation. 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) Form submission feedback delay ≤ 100ms 2) Table sorting/filtering response time ≤ 300ms 3) Clear visual guidance for import process steps. Deduct 5 points for each operation without feedback, 3 points for sluggish table operations, and 5 points for confusing import/export workflows. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "medium"
-}

package/library/management_systems-frontend_backend_platforms/html-navicat-operation-interface.json

@@ -1,68 +0,0 @@
-{
-  "index": 1263,
-  "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 display purposes. Use HTML to help me simulate a Navicat operation interface.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Navicat UI layout structure properly implemented?",
-      "description": "Evaluate whether the HTML code accurately replicates Navicat's signature three-pane layout (connection tree, object browser, and query/result panels). Score 0 if layout is completely different from Navicat, 5 if basic structure is present but with major differences, and 10 if the UI closely resembles the authentic Navicat interface with proper proportions and component placement.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the essential Navicat database connection components implemented?",
-      "description": "Check for connection management interface elements including connection dialog, server type selection (MySQL, PostgreSQL, Oracle, etc.), connection parameters form, and test connection functionality. Deduct 3 points if connection dialog is missing, 3 points if server type selection is limited, and 4 points if connection parameter fields are incomplete. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the database object browser functionality simulated?",
-      "description": "Verify implementation of the hierarchical tree view for databases, tables, views, stored procedures, etc. Tree nodes should be expandable/collapsible and provide contextual actions. Deduct 5 points if the tree structure is flat or non-interactive, 3 points if context menus are missing, and 2 points if icons don't properly represent object types. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the SQL query editor and results display implemented?",
-      "description": "Assess whether the code includes a proper SQL input area with syntax highlighting, execution controls, and a tabulated results panel. Deduct 4 points for missing syntax highlighting, 3 points for absence of execution controls, and 3 points if result display doesn't support pagination or column sorting. 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 SQL syntax, connection failures, large result sets, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dark/light theme switching 2. SQL history with search function 3. Visual query builder). 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 query execution methods) 2. Function modules unrelated to database management (e.g., built-in games) 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 UI components, database logic, and state management), code organization, and maintainability. 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 excessive inline styling instead of CSS classes. 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 matching Navicat's professional look 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 for database operations. Deduct 5 points for each operation without feedback, 3 points for visual after-images during interface transitions, 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/html-patrol-plan-management.json

@@ -1,68 +0,0 @@
-{
-  "index": 1687,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code generated is executable for display when possible. Continue with HTML to create a patrol plan:\n\nSelect patrol route: Choose from preset routes or customize your own route.\n\nSet patrol time: Select start and end times.\n\nAssign patrol personnel: Select patrol officers from the personnel list.\n\nSave plan: Click the \"Save\" button to activate the plan.\n\nEdit patrol plan: Select an existing plan, modify the route, time, or personnel, then click \"Save.\"\n\nDelete patrol plan: Select a plan and click \"Delete.\"\n\nView plan list: Display all patrol plans with filtering options by date, route, and personnel.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the patrol route selection functionality fully implemented?",
-      "description": "Check if the code includes both preset route selection and custom route creation capabilities. The interface should display route options visually (e.g., on a map or as a list) and allow for interactive selection. For custom routes, verify if waypoint creation, modification, and deletion are supported. Score 0 if route selection is missing, 5 if only preset routes are available, and 10 if both preset and fully functional custom route creation are implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are patrol time settings properly implemented?",
-      "description": "Evaluate if the time selection interface provides intuitive date and time pickers for both start and end times. Check if the implementation validates time inputs (preventing end time before start time), handles time zones appropriately, and offers recurring schedule options. Verify if the interface shows visual feedback for selected time periods. Score 0 if time settings are missing, 5 if basic time selection exists but lacks validation, and 10 if time selection is complete with validation and visual indicators.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is personnel assignment functionality complete?",
-      "description": "Review whether the personnel selection interface displays staff availability, shows qualification badges/ratings, and prevents scheduling conflicts. Check if the implementation allows multi-selection of patrol officers and displays their work hours/schedule conflicts. Verify if capacity planning (minimum/maximum officers per patrol) is enforced. Score 0 if personnel assignment is missing, 5 if basic selection exists without conflict checking, and 10 if it's fully implemented with availability checks and qualification filtering.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are plan management operations (save, edit, delete) properly implemented?",
-      "description": "Test if the save, edit, and delete operations are correctly implemented with proper confirmation dialogs, undo capabilities, and data validation. Check if edited plans maintain their historical records and if deletion includes archiving options. Verify if the system prevents deletion of active patrols without supervisor confirmation. Score 0 if these operations are missing, 5 if they exist but lack validation or confirmation features, and 10 if they're fully implemented with all safety measures.",
-      "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 edits, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time GPS tracking integration 2. Weather overlay on patrol routes 3. Mobile notifications for patrol officers 4. AI-suggested optimal patrol routes based on historical incident 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 select personnel with inconsistent UIs) 2. Function modules unrelated to patrol planning (e.g., an embedded social media feed) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow down the interface). 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/service/view layers), component reusability, and responsive design implementation. 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 code doesn't adapt to different screen sizes. 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/html-patrol-record-table-device-testing.json

@@ -1,68 +0,0 @@
-{
-  "index": 1758,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration purposes. Create a patrol record table for reliability device testing using HTML.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the basic HTML structure for the patrol record table properly implemented?",
-      "description": "Check if the HTML document has a complete structure with DOCTYPE declaration, head, and body sections. Verify if semantic HTML5 elements are used appropriately (table, thead, tbody, etc.). Table should include proper column headers and data cells for patrol records. Deduct 5 points if basic structure is missing, 3 points if semantic HTML is not used, 2 points if accessibility attributes are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all necessary data fields for reliability device testing included in the table?",
-      "description": "Evaluate if the table contains essential fields for reliability testing: device ID, device name, inspection date/time, inspector name, test parameters, test results, anomalies, action taken, and next inspection date. Deduct 2 points for each critical field missing, and 1 point for auxiliary fields (like location, comments). Full implementation with comprehensive fields scores 10 points, basic implementation scores 5 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is data input validation implemented for the reliability testing form?",
-      "description": "Check if form validation is implemented for data entry, including required fields, input type restrictions (numbers for measurements, dates for timestamps), valid ranges for test parameters, and data format validation. Deduct 3 points if required field validation is missing, 3 points if numeric validation is absent, 2 points if date format validation is missing, and 2 points if there's no error feedback. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the table include data filtering and sorting capabilities?",
-      "description": "Review if the table implements sorting functionality (by date, device ID, test results) and filtering options (by pass/fail status, date range, device type). Verify if dynamic reordering works without page reload. Deduct 5 points if sorting is missing, 3 points if filtering is absent, and 2 points if the UI controls are not intuitive. Full implementation scores 10 points, partial implementation scores 5 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as empty data, malformed input, edge cases in data display) 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. Color-coded status indicators 2. Interactive data visualization of test results 3. Responsive design for mobile devices 4. Export to CSV/PDF functionality). 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 mechanisms) 2. Function modules unrelated to reliability testing (e.g., unrelated animations) 3. Fancy effects that affect performance (e.g., excessive animations or transitions). 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), code reusability, and maintainability. Deduct 5 points if global variables are overused or if code organization is poor; deduct 3 points if the code duplication rate is too high; deduct 2 points if naming conventions are inconsistent or unclear. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (consistent color scheme for status indicators) 2) Proper layout spacing (table cells properly padded, headers distinguished) 3) Professional font system (readable font sizes, proper contrast). Deduct 3 points for each crowded visual element, 5 points for poor color contrast, and 5 points for inconsistent alignment or spacing. 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 is immediate 2) Sorting/filtering actions respond within 100ms 3) Clear visual indicators for interactive elements. Deduct 5 points for each operation without feedback, 3 points for laggy interactions when handling large datasets, and 5 points for confusing navigation or interaction patterns. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "easy"
-}

package/library/management_systems-frontend_backend_platforms/implement-frontend-backend-app-tsx.json

@@ -1,68 +0,0 @@
-{
-  "index": 783,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and expert responses. Make sure the code you generate is executable for demonstration purposes. Don't worry about security issues for now, and implement both frontend and backend content in app.tsx.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the app.tsx file correctly structured as a React component?",
-      "description": "Evaluate whether the app.tsx file follows proper React component architecture with appropriate imports, functional or class component definition, and proper export. Check for React hooks usage if it's a functional component or lifecycle methods if it's a class component. Score 0 if the file doesn't contain a valid React component, 5 if it has basic structure but with issues, and 10 if it follows all React best practices.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the code include both frontend and backend integration in a single file as requested?",
-      "description": "Check if the app.tsx contains both frontend React code and backend-like functionality (such as API simulations, data handling, or server-side logic). Evaluate if the integration approach is practical within the constraints of a single file. Deduct 5 points if only frontend is implemented, 8 points if backend simulation is missing or severely limited. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there appropriate state management for the application?",
-      "description": "Review whether the code uses proper state management techniques (useState, useReducer, Context API, etc.) for handling application data. Check if state updates are performed correctly without direct mutations. Deduct 3 points for each anti-pattern found (e.g., excessive prop drilling, unnecessary re-renders, improper state updates). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the implementation include proper error handling and loading states?",
-      "description": "Assess whether the code handles potential errors (e.g., failed API calls, invalid inputs) and includes appropriate loading states for asynchronous operations. Give 10 points if comprehensive error boundaries, fallbacks, and loading indicators are implemented. Give 5 points if basic error handling exists but is incomplete. Give 0 points if errors would crash the application.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle edge cases (empty data, network issues, unexpected inputs) and provides appropriate user feedback. Code with strong robustness should gracefully handle various scenarios without breaking. Deduct 2 points for each unhandled edge case. The full score is 10 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. Responsive design with adaptive layout 2. Dark/light mode toggle 3. Accessibility considerations like ARIA attributes and keyboard navigation). 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 state variables or component declarations 2. Unnecessary re-rendering of components 3. Over-engineered solutions for simple problems. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functionality is compromised by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review code organization (component structure, separation of concerns), naming conventions, and code reusability. Deduct 5 points if global variables are overused; deduct 5 points if the code has excessive duplication; deduct 5 points if there's no clear separation between UI, logic, and data. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the UI follows modern design principles: 1) Consistent component styling 2) Proper use of whitespace and alignment 3) Responsive layout that works across device sizes. Deduct 3 points for inconsistent styling, 5 points for poor layout hierarchy, and 5 points for non-responsive designs. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the interactions provide good user experience: 1) Immediate feedback for user actions 2) Smooth transitions between states 3) Intuitive navigation and controls. Deduct 5 points for laggy transitions, 3 points for confusing interaction patterns, and 5 points for missing user feedback. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "easy"
-}

package/library/management_systems-frontend_backend_platforms/industrial-component-defect-detection-system-vue3.json

@@ -1,68 +0,0 @@
-{
-  "index": 911,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable whenever possible. This is for an industrial component defect detection system developed with Vue 3.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is a complete defect detection workflow implemented?",
-      "description": "Check whether the code properly implements the entire industrial defect detection pipeline: image acquisition, preprocessing, feature extraction, classification/detection algorithms, and result visualization. Score 0 if the core detection workflow is missing, 5 points if basic detection is implemented but lacks optimization, and 10 points if a comprehensive pipeline with multiple detection techniques is provided.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Vue 3 implementation technically correct and optimized?",
-      "description": "Evaluate the Vue 3 specific implementation including proper use of Composition API, reactive state management, component design, and Vue lifecycle hooks. Look for proper implementation of <script setup>, ref/reactive usage, and computed properties. Deduct 3 points for each anti-pattern (like not using shallowRef for large objects), 5 points if Suspense is not properly handled for async components, and 3 points if Vue 3 performance features (like v-memo) are not utilized where appropriate. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is real-time image processing and analysis functionality implemented?",
-      "description": "Verify if the system can process images in real-time with WebGL/Web Workers to avoid UI blocking, has proper buffering mechanisms, and implements efficient image processing algorithms. Check if WebRTC is used for camera stream handling and if processing pipeline is optimized. Deduct 5 points if processing causes UI freezes, 3 points if image processing is not parallelized, and 3 points if frame rate drops below 15 FPS for standard operations. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the defect analysis and reporting system comprehensive?",
-      "description": "Examine if the system provides detailed defect classifications, statistical analysis, historical comparisons, and exportable reports. Check for visualization of defect patterns over time, severity classification, and integration with industrial standards. Deduct 3 points if reports lack visual data representation, 5 points if historical analysis is missing, and 3 points if export formats are limited (should support at least PDF, CSV, and JSON). Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common industrial environment issues (network instability, hardware failures, image corruption), implements proper error boundaries, and has recovery mechanisms. Code should handle edge cases like varying lighting conditions and unexpected object presentations. Deduct 5 points if critical error handling is missing, 3 points if there's no degraded functionality mode, and 3 points if error logging/reporting is inadequate. Full score is 10 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 industrial experience (e.g., 1. AI-assisted defect prediction 2. Adaptive learning from operator feedback 3. Real-time defect classification confidence scores 4. Automated camera calibration). 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 image processing pipelines that accomplish the same goal 2. Unnecessary UI elements that distract from the main industrial workflow 3. Heavy animations or effects that could impact system performance in an industrial setting. Deduct 3 points for each redundancy found, and directly deduct 10 points if core detection functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review the industrial-grade architecture (separation of detection algorithms/UI/data storage), automated testing for vision algorithms accuracy, CI/CD integration, and error telemetry. Deduct 3 points if global state is overused, 3 points if test coverage for critical detection algorithms is below 80%, 2 points if the build process isn't optimized for industrial settings, and 2 points if there's no performance profiling implemented. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet industrial UI/UX standards?",
-      "description": "Evaluate if the UI follows industrial design principles: 1) High contrast for factory environments 2) Touch-friendly targets (≥44px) for gloved operation 3) Clear iconography with text labels 4) Proper information hierarchy for critical alerts. Deduct 3 points for poor visibility under varied lighting, 3 points for controls too small for industrial use, 2 points for poor color coding of defects, and 2 points for cluttered dashboards. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the system performance optimized for industrial requirements?",
-      "description": "Judge whether the system meets industrial performance needs: 1) Initial load time ≤3 seconds 2) Detection pipeline latency ≤200ms 3) Responsive UI even during heavy processing 4) Efficient memory management for extended operation. Deduct 3 points if memory leaks occur during continuous operation, 3 points if the system can't handle industrial camera resolutions at full frame rate, 2 points for inefficient asset loading, and 2 points if there's no performance degradation strategy. Full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "hard"
-}

package/library/management_systems-frontend_backend_platforms/insurance-customer-management-system.json

@@ -1,68 +0,0 @@
-{
-  "index": 634,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. Please write code to implement an insurance customer management system. Insurance agents can log in to add and manage customer information, record customer insurance needs and policy history. Customers can log in to view their own policy information, submit claims, and check claim progress. Administrators can review claim applications, manage insurance product information, and generate customer and claims statistical reports.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the user authentication and role-based access control fully implemented?",
-      "description": "Review whether the code implements a secure authentication system with proper session management and distinct roles (agent, customer, administrator) with appropriate permission levels. Check for password hashing, CSRF protection, and session timeout features. Score 0 if authentication is missing, 5 if basic login exists but lacks proper role segregation, and 10 if complete RBAC with security measures is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the customer management functionality complete for agents?",
-      "description": "Verify if agents can add new customers, update customer information, record customer needs assessment, and track policy history. The system should include form validation, data sanitization, and proper relational database structure. Deduct 3 points if customer search functionality is missing, 3 points if data validation is inadequate, and 4 points if there's no way to record customer interactions or needs assessment. Full score requires complete CRUD operations with audit logging.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the policy management system properly implemented?",
-      "description": "Examine if the system allows for creating, updating, and managing policy information with appropriate relationships to customers and agents. Check if policy documents can be uploaded/stored, if premium calculations are included, and if policy status changes (active, lapsed, canceled) are tracked. Deduct 3 points for missing document management, 3 points for absence of policy lifecycle tracking, and 4 points if premium handling is incomplete. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the claims processing workflow complete?",
-      "description": "Assess whether the code implements a complete claims lifecycle: submission by customers, review by administrators, status updates, documentation requirements, and payment processing. Check if the workflow handles multi-step approval processes and notification systems. Deduct 5 points if the workflow is linear without proper state management, 3 points if document upload/management for claims is missing, and 2 points if there's no notification system for status changes. 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, duplicate submissions, database connection failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include try-catch blocks, input validation, and graceful error handling. Give 10 points for comprehensive error handling, 5 points for basic validation only, and 0 points if exceptions are unhandled.",
-      "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 risk assessment tool 2. Automated policy renewal reminders 3. Interactive dashboards for claims analysis 4. Mobile-responsive design with push notifications). 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. Duplicate functionality across different modules (e.g., multiple customer search implementations) 2. Features unrelated to insurance management (e.g., built-in games or unnecessary social features) 3. Over-engineered components that complicate the system. Deduct 3 points for each redundancy found, and directly deduct 10 points if core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as MVC pattern or service-oriented architecture), unit test coverage, and build process automation. Check for code documentation, naming conventions, and consistent coding style. Deduct 5 points if global state pollution is found; deduct 3 points if the code lacks comments or documentation; deduct 2 points if there's no evidence of testing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the UI follows modern design principles: 1) Harmonious color scheme appropriate for financial/insurance context 2) Proper information hierarchy and form layout 3) Consistent typography and component styling across the application. Deduct 3 points for cluttered dashboards, 4 points for confusing navigation structure, and 3 points for inconsistent visual elements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the system performance and data security adequately addressed?",
-      "description": "Judge whether the system handles performance considerations and security requirements: 1) Data encryption for sensitive customer information 2) Pagination for large data sets 3) Optimized database queries 4) Proper logging of system access and changes. Deduct 3 points for missing data encryption, 2 points for poor query optimization, 3 points for inadequate audit logging, and 2 points if there's no consideration for data backup/recovery. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "hard"
-}

package/library/management_systems-frontend_backend_platforms/insurance-customer-service-system-design.json

@@ -1,68 +0,0 @@
-{
-  "index": 698,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Insurance Company Customer Service System Design\n\nYou are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the code you generate is executable for demonstration.\n\nAn insurance company customer service contact center needs to build an online customer service system with the following requirements:\n- Access to the online customer service portal through the official WeChat mini program\n- 24-hour interaction with a chatbot once entered\n- The chatbot can be integrated with third-party applications\n- Visitors can choose whether to transfer to human agents for continued service\n\nPlease design a set of runnable code based on the above requirements.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the WeChat Mini Program integration properly implemented?",
-      "description": "Check if the code includes proper integration with WeChat Mini Program API, including authentication, user session management, and navigation to the customer service portal. Verify if the Mini Program project structure follows WeChat development specifications with proper app.json, app.js, and page configurations.0 points if no WeChat Mini Program code is provided, 5 points if basic structure exists but lacks proper API integration, 10 points if fully implemented with proper authentication flow and complete navigation to customer service.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the 24-hour chatbot interaction system properly designed?",
-      "description": "Evaluate if the chatbot system is designed to handle continuous 24-hour operation with proper session management, conversation state persistence, and error recovery. Check if the system includes time-zone handling for global accessibility and has mechanisms to maintain context across extended conversations.0 points if no chatbot implementation is provided, 5 points if basic chatbot exists but lacks 24-hour operational capabilities, 10 points if the solution fully addresses 24-hour availability with proper session persistence and recovery mechanisms.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the third-party integration capability implemented?",
-      "description": "Assess if the code provides flexible APIs or interfaces for third-party application integration. This should include webhook support, authentication mechanisms for external systems, standardized data exchange formats, and proper documentation for integration points.0 points if no integration capabilities exist, 5 points if basic API endpoints are defined but lack security or flexibility features, 10 points if comprehensive integration solutions are provided with proper security, documentation and example implementations.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the human agent transfer mechanism properly designed?",
-      "description": "Examine if the system implements a smooth transfer mechanism from chatbot to human agents. Check for presence of agent availability tracking, queue management, conversation context preservation during transfer, and notification systems for both users and agents.0 points if no transfer mechanism exists, 5 points if basic transfer functionality is implemented but lacks queue management or context preservation, 10 points if comprehensive transfer system is provided with proper handling of edge cases like agent unavailability.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruptions, API failures, invalid inputs, etc.) and provide friendly error prompts or recovery mechanisms. Check for presence of exception handling, input validation, and graceful degradation patterns.0 points if no exception handling exists, 5 points if basic error handling is implemented but lacks recovery mechanisms, 10 points if comprehensive error handling with proper user feedback and recovery paths is provided.",
-      "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. Sentiment analysis to detect customer frustration 2. Automatic insurance policy recommendation based on conversation context 3. Voice/video chat capabilities 4. Multi-language support).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. Duplicate implementations of similar functions 2. Function modules unrelated to insurance customer service 3. Overly complex UI elements or processes that complicate the user experience.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, business logic, and data layers), code reusability, naming conventions, and documentation quality. Check for presence of unit tests, configuration management, and deployment considerations.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 no documentation or comments are provided. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the UI design follows WeChat Mini Program design guidelines and insurance industry best practices: 1) Consistent with WeChat design language 2) Professional color scheme appropriate for financial services 3) Clear information hierarchy and readability 4) Accessible design for all users.Deduct 3 points for each inconsistency with WeChat design guidelines, 5 points for inappropriate color schemes that don't convey trust and professionalism, and 5 points for poor information architecture. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and user-focused?",
-      "description": "Judge whether the customer journey is intuitive and efficient: 1) Clear indicators when chatting with bot vs. human 2) Smooth transitions between different conversation states 3) Appropriate loading states and feedback 4) Easy access to common insurance queries or functions.Deduct 5 points for missing user feedback during operations, 3 points for confusing navigation between bot and human service, and 5 points for excessive steps to complete common customer service tasks. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "medium"
-}