@getollie/cli 0.0.4 → 0.2.0

package/library/management_systems-frontend_backend_platforms/product-sketch-to-prototype-vue-springboot.json

@@ -1,68 +0,0 @@
-{
-  "index": 706,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable whenever possible. I need to input product sketches, and I want you to provide a one-stop solution to generate product prototypes, frontend code in Vue, and backend code in Spring Boot (including MySQL database table structure design).",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the sketch parsing and analysis system fully implemented?",
-      "description": "Review whether the code accurately implements sketch image upload, parsing, and UI element recognition through computer vision or machine learning algorithms. Check if it can identify common UI components (buttons, input fields, navigation bars, etc.) and extract layout information. Score 0 if no sketch processing is implemented, 5 if only basic image upload is handled, and 10 if comprehensive sketch-to-component mapping with position/size extraction is fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Vue frontend code generation engine properly implemented?",
-      "description": "Evaluate whether the system generates syntactically correct and executable Vue 3 components with proper template structure, reactive data binding, and component lifecycle management. Check if generated code includes proper props, events, and styling. Deduct 5 points if components are not properly structured, 3 points if Vue composition API is not utilized correctly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the Spring Boot backend architecture and MySQL integration complete?",
-      "description": "Review whether the generated Spring Boot application includes proper REST API endpoints, service layer architecture, JPA entity mappings, and MySQL database connectivity. Check for proper dependency injection, exception handling, and CRUD operations. Deduct 5 points if database relationships are not properly defined, 3 points if API documentation is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the end-to-end prototype generation workflow seamless?",
-      "description": "Assess whether the system provides a complete pipeline from sketch input to deployable prototype, including automatic code compilation, dependency management, and preview functionality. Check if generated frontend and backend can communicate properly through API calls. Deduct 5 points if manual intervention is required for code compilation, 3 points if API integration between frontend and backend is not automated. Give 10 points if fully automated.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid sketch uploads, parsing failures, code generation errors, database connection issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time preview during sketch analysis 2. Smart component suggestions based on design patterns 3. Automatic responsive design generation 4. Integration with popular UI frameworks). 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 file upload handlers) 2. Function modules unrelated to prototype generation (e.g., built-in image editing tools) 3. Overly complex AI models that don't improve accuracy significantly. 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 separating sketch processing/code generation/template engines), proper error handling, configuration management, and build 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 environment configuration is hardcoded. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the generated prototypes and the tool's UI follow 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) 4) Consistent component styling. 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 prototype generation process and resulting prototypes have smooth interactions: 1) Sketch upload and processing feedback ≤ 2 seconds 2) Code generation progress indicators 3) Generated prototype animations between 300-500ms 4) Clear visual focus guidance during the generation workflow. Deduct 5 points for each operation without feedback, 3 points for laggy transitions during code generation, 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/project-financing-promotion.json

@@ -1,68 +0,0 @@
-{
-  "index": 1418,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure the generated code is executable for demonstration. Management units can use this section to promote high-quality projects and manage financial institutions participating in investment and financing, ensuring that investment and financing work proceeds efficiently and in an orderly manner. Specific functions should include financial institution management information, project financing service classification, project financing information inquiry, and project financing promotion.\n\n2.4. Project Financing Promotion\nManagement units can recommend quality projects to financial institutions within the system, and financial institutions can directly approach these projects.\n\nBased on the above requirements, please generate a project financing recommendation function using Vue2 and Element UI pages.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the project financing recommendation interface fully implemented?",
-      "description": "Review whether the code accurately implements all required components using Vue2 and Element UI, including project listing, filtering mechanism, recommendation modal, and financial institution selection. Score 0 if core functionality is missing, 5 if basic functionality is implemented without proper interaction, and 10 if the entire recommendation workflow is complete with proper state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all the required data models and CRUD operations properly implemented?",
-      "description": "Check whether the code includes proper data structures for projects, financial institutions, and recommendation relationships. Verify if CRUD operations (Create, Read, Update, Delete) for recommendations are implemented with proper validation. Score 0 if data models are missing, 5 if basic models exist but lack complete operations, and 10 if all models and operations are fully implemented with proper error handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the project filtering and search functionality well-designed?",
-      "description": "Evaluate whether the implementation includes comprehensive filtering options (by industry, investment size, region, etc.) and an efficient search mechanism. The search should be responsive (under 300ms) with debounce handling. Deduct 3 points if advanced filtering is missing, 3 points if search performance is poor, and 4 points if there's no visual feedback during searching operations.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a well-designed recommendation workflow with status tracking?",
-      "description": "Check if the recommendation system includes status tracking (pending, viewed, interested, declined), notification mechanisms, and follow-up functionality. Recommendation history should be accessible and visualized. Deduct 3 points for missing status tracking, 4 points for lack of notification system, and 3 points if recommendation history isn't properly organized and accessible.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as network failures, invalid input, server errors, 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. AI-based matching algorithm for project-institution compatibility 2. Interactive analytics dashboard showing recommendation patterns 3. Automated follow-up scheduling system). 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 filter projects) 2. Function modules unrelated to financing recommendations (e.g., a built-in chat system when notifications would suffice) 3. Fancy effects that affect performance (e.g., complex 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 UI components, services, and state management), Vue best practices (proper use of props, computed properties, watchers), and build process automation. Deduct 5 points if global state pollution is found or Vue patterns are misused; 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 Element UI implementation follows modern design principles: 1) Consistent use of Element UI components without visual conflicts 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional typography and data visualization. Deduct 3 points for inconsistent component usage, 5 points for poor information hierarchy, and 5 points for cluttered layouts with improper alignment. 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 feedback for recommendation actions. Deduct 5 points for operations without feedback, 3 points for janky transitions, and 5 points for unintuitive recommendation workflows that require excessive clicks. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "easy"
-}

package/library/management_systems-frontend_backend_platforms/project-financing-service-classification.json

@@ -1,68 +0,0 @@
-{
-  "index": 1197,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration. Management units can use this section to promote high-quality projects and manage financial institutions participating in investment and financing, ensuring that overall investment and financing work proceeds efficiently and orderly. Specific functions should include financial institution management information, project financing service classification, project financing information inquiry, and project financing promotion.\n\n2.2. Project Financing Service Classification\nClassify projects according to their industry, field, and other relevant information, and match different financial institutions based on these classifications. Through this classification matching, when projects need financing, they can quickly match with financial institutions that align with the project characteristics.\n\nBased on the requirements, generate a project financing service classification using Vue2+Element UI.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the project financing classification system fully implemented?",
-      "description": "Evaluate whether the code accurately implements a comprehensive classification system using Vue2+Element UI. Check if it includes industry categories, sub-fields, and relevant project attributes with proper hierarchical relationships. Score 0 if no classification structure exists, 5 if only basic industry categories are implemented, and 10 if it includes a complete multi-level classification system with validation logic.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the financial institution matching algorithm implemented?",
-      "description": "Review the matching algorithm that pairs projects with financial institutions based on classification criteria. The algorithm should consider multiple factors (industry preference, investment range, risk appetite) and provide weighted scoring. Deduct 5 points if matching is based on only a single attribute, 3 points if there's no optimization for match quality. The full score is 10 points for an algorithm with comprehensive criteria and ranked results.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the classification-based search and filtering system implemented?",
-      "description": "Check whether the UI provides advanced search and filtering capabilities based on the classification system. It should include multi-condition filtering, faceted search, and the ability to save search preferences. Deduct 5 points if only basic search is implemented, 3 points if search history is not persistent. Award full 10 points for a comprehensive system with performance optimization for large datasets.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a project-institution matching visualization component?",
-      "description": "Evaluate whether the code includes data visualization elements (charts, matrices, etc.) showing the matching between projects and financial institutions. It should display matching strength, comparison views, and historical matching patterns. Score 0 if no visualization exists, 5 if only basic charts without interaction are implemented, and 10 if it includes interactive visualizations with drill-down capabilities.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as empty search results, network errors during data fetching, invalid classification inputs, 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. AI-powered recommendation system 2. Real-time industry trend indicators 3. Interactive matching simulation tool). 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 classification methods 2. Function modules unrelated to financing services (e.g., social media sharing without business value) 3. Fancy effects that affect performance (e.g., unnecessary animations in data tables). 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 classification logic/UI components/data services), unit test coverage, and Vue component reusability. Deduct 5 points if prop drilling is overused instead of proper state management; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no component documentation exists. 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 application (professional blues and neutrals) 2) Proper layout spacing in Element UI components 3) Professional typography with clear hierarchy for financial data. Deduct 3 points for each inconsistent UI component, 5 points for poor information density in classification displays, and 5 points for hard-to-read financial metrics. 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 professional financial application standards: 1) Immediate feedback when selecting classification criteria 2) Smooth transitions between different classification views 3) Clear visual cues for matched financial institutions. Deduct 5 points for sluggish classification tree rendering, 3 points for jarring transitions between views, and 5 points for confusing navigation between classification levels. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "easy"
-}

package/library/management_systems-frontend_backend_platforms/project-management-system-for-teams.json

@@ -1,68 +0,0 @@
-{
-  "index": 601,
-  "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. Please write code to implement a project management system where team members can create projects, assign tasks, and update task progress; project managers can view the overall progress of all projects, generate project reports, and manage team members.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core project management functionality fully implemented?",
-      "description": "Evaluate whether the code implements essential project management features: project creation, task assignment, and progress tracking. Check if the data model properly represents projects, tasks, and users with appropriate relationships. Score 0 if the core functionality is missing, 5 if only basic features are implemented without proper relationships, and 10 if the system has a complete implementation with validation and business rules.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the task management system properly designed?",
-      "description": "Review whether the task management system includes status tracking, priority assignment, dependency management, and deadline handling. Check if tasks can be properly assigned to team members with notifications. Deduct 3 points if dependency management is missing, 3 points if there's no deadline tracking mechanism, and 3 points if priority assignment is not implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the project manager features properly implemented?",
-      "description": "Assess the implementation of project manager-specific features like overall progress tracking, report generation, and team management. Verify that managers can view consolidated dashboards showing project statuses, generate various reports (e.g., burndown charts, completion rates), and manage team member assignments and roles. Deduct 3 points if dashboard views are missing, 4 points if reporting functionality is absent, and 3 points if team management features are incomplete. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the user authentication and authorization system properly implemented?",
-      "description": "Examine whether the system includes proper authentication (login/logout) and role-based authorization (differentiating between regular team members and project managers). Check for security best practices like password hashing, protection against common vulnerabilities, and proper session management. Deduct 5 points if role-based access control is missing, 3 points if authentication lacks security features, and 2 points if session management is insecure. 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, database connection errors, concurrent edits, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should implement proper error handling, input validation, and transaction management. If the robustness is excellent, give 10 points. If it's average, give 5 points, and if no error handling exists, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Automated task assignment based on workload 2. Real-time collaboration features 3. Interactive visualizations of project dependencies). 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 track progress) 2. Function modules unrelated to project management (e.g., built-in chat system if not essential) 3. Overly complex features that add little value. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating business logic/data access/presentation 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 updates, 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/project-management-system-with-team-collaboration.json

@@ -1,68 +0,0 @@
-{
-  "index": 632,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable and demonstrable when possible. Please write code to implement a project management system where team members can view a list of all projects on the frontend page, including project name, person in charge, progress, deadline, and other information. Users should be able to create new projects, assign tasks, and update project progress status. Project managers should be able to log into the backend, manage project details, assign tasks to team members, and view the overall progress of projects.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the project list view implementation complete?",
-      "description": "Check whether the frontend properly displays all projects with required information (name, person in charge, progress, deadline). Verify if the list implements sorting/filtering capabilities and responsive design for different screen sizes. Score 0 if the project list is missing, 5 if it's basic without sorting/filtering, and 10 if fully implemented with advanced features like pagination and search functionality.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the project creation and task assignment functionality implemented properly?",
-      "description": "Evaluate whether users can create new projects with all required fields and assign tasks to team members. Check for form validation, error handling, and user feedback. Deduct 5 points if creation lacks validation, 3 points if task assignment is missing, and 5 points if there's no confirmation or success feedback. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the progress tracking and status update system functional?",
-      "description": "Assess if the system allows for updating project progress status with appropriate visualizations (progress bars, charts, etc.). Verify if status changes are persistent and if there's history tracking. Give 10 points if fully implemented with real-time updates and visualization, 5 points if basic functionality exists but lacks visualization, 0 points if missing entirely.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the admin/manager backend complete with proper authorization?",
-      "description": "Verify if the backend includes authentication, role-based access control, and proper security measures. Check if project managers can manage project details and have access to comprehensive dashboards. Deduct 5 points if authentication is missing/weak, 3 points for incomplete dashboards, and 5 points if role separation is not implemented. 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, server errors, 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 collaboration tools 2. Automated deadline reminders 3. Intelligent task prioritization 4. Performance analytics dashboards). 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 update tasks) 2. Function modules unrelated to project management (e.g., unnecessary social features) 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 frontend/backend concerns, using components/services architecture), unit test coverage, and build process automation. Deduct 5 points if global state management is poorly implemented; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between business logic and UI. 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 for important actions. Deduct 5 points for each operation without feedback, 3 points for sluggish transitions when updating project statuses, and 5 points if critical actions (like saving changes) lack clear confirmation. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "hard"
-}

package/library/management_systems-frontend_backend_platforms/prototype-interface-asset-overview-cloud-security.json

@@ -1,68 +0,0 @@
-{
-  "index": 1043,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to create executable code for demonstration whenever possible. I'm a programmer - please help me use HTML and JS to create a prototype interface for the asset overview page in a cloud security center's asset management section.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the asset overview dashboard properly structured?",
-      "description": "Evaluate whether the code implements a coherent dashboard layout with appropriate sections for asset inventory, security status, risk distribution, and alert summaries. Check if the HTML structure uses semantic elements correctly (header, main, section, etc.). Score 0 if there's no clear dashboard structure, 5 if basic elements exist but lack organization, and 10 if the layout follows security dashboard best practices with logical information hierarchy.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are data visualization components implemented effectively?",
-      "description": "Review the implementation of charts and graphs (e.g., asset distribution pie charts, risk trend line charts, vulnerability bar charts). Assess whether appropriate visualization libraries are used (D3.js, Chart.js, etc.) and if the visualizations convey security insights clearly. Deduct 5 points if visualizations are static/non-interactive, 3 points if data binding is missing, and 2 points if accessibility features are absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a functional asset filtering and search system?",
-      "description": "Check whether the code implements a search mechanism with filtering options by asset type, risk level, compliance status, etc. Verify if the filtering system includes real-time feedback and result counting. Score 0 if searching/filtering is absent, 5 if basic search exists without advanced filters, and 10 if the implementation includes both search, multi-criteria filtering, and performant result handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the interface include proper security status indicators and alerts?",
-      "description": "Assess whether the code implements visual indicators for security status (threat levels, compliance status) and notification systems for security alerts. Verify that the indicators use appropriate color coding, severity levels, and time stamps. Deduct 5 points if security indicators lack visual differentiation, 3 points if there's no alert prioritization system, and 2 points if time-sensitive information handling is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as failed API calls, empty data sets, user input errors, etc.) and provide friendly error prompts or recovery mechanisms. Check for proper error handling, data validation, and fallback displays. Code with strong robustness should handle all 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 security monitoring experience (e.g., 1. Real-time threat visualization 2. Interactive topology maps showing asset relationships 3. Customizable risk scoring system 4. Auto-categorization of assets using AI). 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 view the same asset data) 2. Function modules unrelated to security asset management (e.g., irrelevant system tools) 3. Fancy effects that affect performance (e.g., excessive animations that slow dashboard 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 fetching/processing/visualization layers), code reusability, and performance optimization. Deduct 5 points if global variable pollution is found or if design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no performance optimization techniques are used (e.g., lazy loading, pagination). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional security dashboard standards?",
-      "description": "Evaluate whether the overall design follows modern security dashboard principles: 1) Appropriate color scheme (using blue/green for safe, yellow for warnings, red for critical issues) 2) Proper information density and layout (critical information accessible without scrolling) 3) Professional typography system (consistent font hierarchy, readable data tables). Deduct 3 points for each cluttered visual element, 5 points for misleading security status indicators, and 5 points for poor information architecture. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the interactive elements meet security operations needs: 1) Dashboard updates/refreshes without page reloads 2) Quick access to detailed asset information with ≤ 2 clicks 3) Responsive design for different screen sizes 4) Smooth transitions between data views. Deduct 5 points for slow dashboard loading (> 2s), 3 points for laggy interactions during filtering/sorting, and 5 points for non-responsive designs that break on different screens. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "easy"
-}

package/library/management_systems-frontend_backend_platforms/python-flet-floating-window-application.json

@@ -1,68 +0,0 @@
-{
-  "index": 1018,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code when possible. Create a floating window application using the Python flet framework.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is a functional floating window application correctly implemented with flet?",
-      "description": "Verify whether the code creates a properly functioning floating window that can be moved around the screen. This should include a title bar, resize options if applicable, and proper window decoration settings. Score 0 if no floating window is created, 5 if a basic window is created but lacks mobility, and 10 if the floating window is fully implemented with proper window flags and styling.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the window draggable and properly positioned?",
-      "description": "Check whether the floating window can be dragged across the screen by the user. The implementation should include proper mouse event handling for drag operations, appropriate cursor changes during dragging, and boundary checks to prevent the window from being dragged off-screen. Deduct 3 points if dragging is implemented but unstable, 5 points if dragging is missing, and 2 points if boundary checks are absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are essential window controls implemented?",
-      "description": "Evaluate the implementation of window control buttons (minimize, maximize/restore, close) and their functionality. These controls should be visually distinct, properly positioned, and trigger the correct actions. Each missing control deducts 2 points. If the controls exist but don't function properly, deduct 5 points. Additional points should be awarded for controls that have appropriate hover effects and provide visual feedback. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the application handle window state management properly?",
-      "description": "Review how the application manages window states (normal, minimized, maximized) and transitions between them. The code should maintain the window's previous size and position when restoring from a minimized or maximized state. Verify that window state changes are smooth and don't cause visual glitches. Deduct 5 points if state transitions cause visual artifacts, and 7 points if state management is entirely 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 screen resolution changes, multiple monitors, system theme changes, etc.) and provide graceful error handling. Code with strong robustness should handle these edge cases effectively, 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. Custom window shapes 2. Translucent or blur effects 3. Animated transitions when minimizing/maximizing). 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 close the window) 2. Function modules unrelated to the floating window concept (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow down the application). 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/logic/event handling), code organization, and adherence to Python best practices. 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 error handling or logging. 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 consistent principles) 3) Professional font system (readable fonts with appropriate sizing and consistent style). 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 stuttering during animations, 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/python-pyside6-stock-trading-management.json

@@ -1,68 +0,0 @@
-{
-  "index": 1567,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes. Design a stock trading management software using Python and PySide6, with a Treeview displaying account lists on the left, portfolio holdings in the upper right, and transaction details in the lower right. The window should automatically resize. The account list, portfolio holdings, and transaction details should automatically connect to an SQLite database. Use pd.to_sql and pd.read_sql for database operations, and implement DDL for the database structure.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the basic UI layout properly implemented with PySide6?",
-      "description": "Check if the code creates a main window with a proper layout containing a TreeView for account lists on the left, portfolio holdings in the upper right, and transaction details in the lower right. Evaluate whether QSplitter or appropriate layout managers (QVBoxLayout, QHBoxLayout, QGridLayout) are used to organize these widgets. Verify that the TreeView properly displays hierarchical account data. Score 0 if basic layout is missing, 5 if layout exists but has structural issues, and 10 if layout is properly implemented with all required components.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is automatic window resizing implemented correctly?",
-      "description": "Examine whether the application implements proper window resize policies using sizePolicy attributes, minimum/maximum size constraints, or stretch factors in layouts. Check that all components (TreeView, portfolio table, transaction table) resize proportionally when the main window is resized. Verify that scrollbars appear when content exceeds the available space. Deduct 5 points if resizing behavior is inconsistent or if some UI elements become unusable during resizing. Deduct 3 points if only basic Qt automatic resizing is used without thoughtful constraints.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the SQLite database structure properly implemented with DDL?",
-      "description": "Review whether the code includes proper Data Definition Language (DDL) statements that create the necessary tables with appropriate fields, data types, and constraints (PRIMARY KEY, FOREIGN KEY, NOT NULL, etc.) for accounts, portfolio holdings, and transactions. Check if relationships between tables are properly defined. Deduct 5 points if table relationships are incorrect or missing, 3 points if constraints are incomplete, and 2 points if data types are inappropriate for financial data. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is data synchronization between UI and database implemented correctly?",
-      "description": "Evaluate whether the code properly uses pd.to_sql for writing data and pd.read_sql for reading data from the SQLite database. Check if data changes in the UI are properly committed to the database and if data changes in the database are properly reflected in the UI. Verify that database transactions are properly managed (commit/rollback) and that the application handles database errors. Deduct 5 points if there's no error handling for database operations, 3 points if transaction management is missing, and 5 points if two-way synchronization is incomplete.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as database connection failures, data format errors, invalid user inputs, etc.) and provide friendly error prompts or recovery mechanisms. Check if the application validates user inputs and handles edge cases properly. 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 stock price updates 2. Visual portfolio performance charts 3. Trade alert notifications 4. Customizable dashboard widgets). 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 database connection methods coexisting) 2. Function modules unrelated to stock trading management (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., excessive animations or unnecessary real-time updates). 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/data/business logic layers), implementation of design patterns, and code organization. Check if the code follows PEP 8 guidelines and includes proper documentation. 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 insufficient documentation for key functions. 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 consistent principles) 3) Professional font system (readable font size, appropriate line height). Check if the UI elements are aligned properly and if the application uses Qt style sheets or themes consistently. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the application suitable for financial data management?",
-      "description": "Judge whether the application meets specific requirements for financial software: 1) Proper decimal precision for monetary values 2) Clear visual distinction between debits and credits 3) Data integrity safeguards 4) Transaction history preservation 5) Date filtering capabilities. Deduct 3 points for each missing financial-specific feature, 5 points for improper money calculations, and 5 points for lack of data validation specific to financial transactions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "easy"
-}