@getollie/cli 0.0.1

package/library/management_systems-frontend_backend_platforms/project-management-system-with-team-collaboration.json

@@ -0,0 +1,68 @@
+{
+  "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

@@ -0,0 +1,68 @@
+{
+  "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

@@ -0,0 +1,68 @@
+{
+  "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

@@ -0,0 +1,68 @@
+{
+  "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"
+}

package/library/management_systems-frontend_backend_platforms/qiankun-react-micro-app-manual-load.json

@@ -0,0 +1,68 @@
+{
+  "index": 433,
+  "question": "You are a code expert, please utilize your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration. You are a frontend expert, proficient in various micro-frontend architectures.\n\nUsing the qiankun framework, with all child applications manually loaded using loadMicroApp, write a simple React DEMO.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the qiankun framework properly initialized?",
+      "description": "Check if the main application correctly initializes qiankun with proper configuration (prefetch strategy, sandbox options, etc.). Verify that the initialization includes error handling for micro-app registration failures. Score 0 if qiankun is not initialized at all, 5 if basic initialization exists but lacks configuration options, and 10 if fully configured with error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the micro-app loading mechanism correctly implemented using loadMicroApp?",
+      "description": "Verify that loadMicroApp is correctly used instead of registerMicroApps/start pattern. Check if the manual loading includes proper lifecycle management (mount, unmount, update) with appropriate error handling. Deduct 5 points if loadMicroApp is incorrectly used, 3 points if lifecycle events are not properly managed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the container elements for micro-apps properly managed?",
+      "description": "Examine if the React main application correctly creates and manages DOM container elements for each micro-app. Check if containers are created, referenced, and cleaned up appropriately to prevent memory leaks. Deduct 5 points for missing cleanup on unmount, 3 points for inefficient container management. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper data/state communication between main app and micro-apps?",
+      "description": "Evaluate if the demo implements proper communication mechanisms between the main app and micro-apps (props passing, custom events, shared state, etc.). Check if the communication is bidirectional and handles edge cases like undefined values. Deduct 5 points if communication is one-way only, 3 points if error 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 micro-app loading failures, network interruption, missing dependencies, 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. Dynamic micro-app loading based on user permissions 2. Performance monitoring for micro-apps 3. Preloading strategy for frequently used micro-apps). 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 micro-app loaders coexisting) 2. Function modules unrelated to micro-frontend architecture (e.g., unnecessary third-party libraries) 3. Fancy effects that affect performance (e.g., excessive animations during micro-app 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 config/loader/router 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) Micro-app loading and rendering delay ≤ 300ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual loading states during micro-app switches. Deduct 5 points for each micro-app transition without loading indicator, 3 points for jarring or flickering transitions, and 5 points for slow micro-app rendering (>1s). The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}

package/library/management_systems-frontend_backend_platforms/qt-interface-for-solidworks-ansys-data.json

@@ -0,0 +1,68 @@
+{
+  "index": 269,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to ensure that the code you generate is executable for demonstration purposes. How can I implement a UI interface using QT that can call SolidWorks models and Ansys data? The functionality to implement is using QT to enable calls to SolidWorks and Ansys.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Qt-SolidWorks integration properly implemented?",
+      "description": "Review whether the code correctly implements the COM interface or SolidWorks API to communicate with SolidWorks models. Check for proper initialization, error handling during connection, and clean release of COM objects. Score 0 if no integration is implemented, 5 if basic model loading works but with limitations, and 10 if full model manipulation (loading, viewing, modifying) is properly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Qt-Ansys data integration functionality complete?",
+      "description": "Evaluate whether the code implements proper ways to access and manipulate Ansys data, either through Direct API, scripting interfaces (Python/APDL), or file-based communication. Check if it handles different data types (FEA results, thermal analysis, etc.). Deduct 5 points if only read-only operations are supported, and 3 points if the integration lacks error recovery mechanisms. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the data exchange mechanism between applications robust?",
+      "description": "Assess how data is exchanged between Qt, SolidWorks, and Ansys. Look for proper data format conversions, synchronization mechanisms, and handling of large datasets. A complete implementation should include progress indicators for long operations and graceful error handling when data transfer fails. Deduct 5 points if data synchronization is one-way only, 3 points if there's no data validation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the UI provide comprehensive visualization of engineering data?",
+      "description": "Check if the Qt interface provides proper visualization components for SolidWorks models and Ansys results (stress contours, deformation plots, etc.). Review if the implementation uses appropriate Qt visualization libraries (like Qt3D, VTK integration, or custom OpenGL widgets). Deduct 5 points if visualization is static only, 3 points if interactive elements are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as application crashes, API version mismatches, memory limitations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time parameter sensitivity analysis 2. Automated report generation from simulation results 3. Gesture-based 3D model manipulation). 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 loading mechanisms) 2. Function modules unrelated to engineering analysis (e.g., built-in social media sharing) 3. Fancy effects that affect performance (e.g., unnecessary animations during critical calculations). 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/external API calls), unit test coverage, and error logging mechanisms. 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 proper dependency management for the external tools. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional engineering software standards?",
+      "description": "Evaluate whether the UI design follows engineering software conventions: 1) Properly organized toolbars and ribbons for common operations 2) Clear visual hierarchy for model browsers and property panels 3) Consistent use of engineering terminology and iconography. Deduct 3 points for cluttered workspaces, 5 points for non-standard engineering visualization coloring schemes, and 5 points for poor layout of critical data. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the performance optimization adequate for engineering workflows?",
+      "description": "Judge whether the implementation handles large engineering datasets efficiently: 1) Background processing for time-consuming operations 2) Appropriate level-of-detail rendering for complex models 3) Efficient memory management when dealing with large simulation results. Deduct 5 points for UI freezes during calculations, 3 points for excessive memory consumption, and 5 points for lack of caching mechanisms for frequently accessed data. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}

package/library/management_systems-frontend_backend_platforms/qt-palantir-style-web-ui-project.json

@@ -0,0 +1,68 @@
+{
+  "index": 266,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you generate is executable for demonstration. Create a UI project using QT based on Palantir's style with web interface development as the foundation. This project should include Palantir's main elements and facilitate easy modification of styles, language switching between Chinese and English, etc. How can this be implemented? Please provide specific and complete code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Qt UI framework properly set up with web interface integration?",
+      "description": "Evaluate whether the code properly establishes a Qt framework with web capabilities (WebEngineView or equivalent). Check if the bridge between Qt C++ and web components is correctly implemented with proper data binding. Score 0 if there's no integration between Qt and web, 5 if basic integration exists but with limitations, and 10 if there's seamless two-way communication between Qt and web components.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the implementation replicate Palantir's distinctive UI style accurately?",
+      "description": "Verify if the code implements key Palantir UI characteristics: dark theme with accent colors (typically blue/teal), data-dense interfaces, card-based components, and distinctive typography. Score based on completeness: 0 points if no Palantir styling is present, 5 points if basic styling elements are included, 10 points if the UI closely resembles Palantir's professional interface with attention to shadows, borders, and spacing.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the style modification system flexible and comprehensive?",
+      "description": "Evaluate if the code includes a robust theming system that allows dynamic style changes. Check for separation of style definitions (CSS/SCSS or Qt style sheets), theme manager implementation, and runtime style switching capability. Deduct 5 points if styles are hardcoded, 3 points if theme changes require application restart. The full score is 10 points for a fully abstracted theming system with hot-swappable styles.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the language switching functionality properly implemented?",
+      "description": "Check if internationalization is correctly implemented with a translation management system supporting at least Chinese and English. The implementation should include translation files/resources, dynamic text replacement mechanism, and proper handling of text expansion/contraction between languages. Deduct 5 points if translations are hardcoded, 3 points if language changes require application restart, and 2 points if right-to-left language support is missing. 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 resource loading failures, network interruption, user operation 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. Animated transitions between views 2. Data visualization components 3. Gesture-based interactions). 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 theme management systems) 2. Function modules unrelated to UI framework (e.g., unnecessary data processing logic) 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/logic/data layers), class organization, and build process setup. 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 properly configured with QMake/CMake. 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 with Palantir's palette) 2) Proper layout spacing (element spacing follows consistent principles) 3) Professional font system (appropriate sizing hierarchy, consistent font families). Deduct 3 points for each crowded visual element, 5 points for inconsistent color schemes, 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 navigation, 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/react-antd-admin-template.json

@@ -0,0 +1,68 @@
+{
+  "index": 1300,
+  "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 can be executed and displayed. Help me create a backend management template using React 18, Ant Design, Design Pro, and Redux.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the React 18 framework architecture properly implemented?",
+      "description": "Review whether the code correctly utilizes React 18's new features including Concurrent Features, Automatic Batching, and Suspense for data fetching. Check if the project structure follows modern React patterns with proper component composition and hooks usage. Score 0 if using outdated React patterns, 5 if basic React 18 setup without new features, and 10 if fully leveraging React 18's capabilities including Concurrent Rendering and new APIs.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is Ant Design integration comprehensive and theme-consistent?",
+      "description": "Evaluate whether Ant Design components are properly integrated with consistent theming, proper ConfigProvider setup, and customized design tokens. Check if the implementation includes responsive design, proper form validation, and accessibility features. Deduct 5 points if default styling is used without customization, 3 points if responsive breakpoints are not handled properly. Full score requires complete theme customization and component optimization.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is Ant Design Pro template structure and routing implemented correctly?",
+      "description": "Check whether the code implements proper ProLayout, route configuration with menu generation, and authentication guards. Evaluate if breadcrumb navigation, multi-tab support, and permission-based menu rendering are included. Deduct 5 points if basic layout structure is missing, 3 points if route guards are not implemented. Full score requires complete admin template features including settings drawer and layout customization.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is Redux state management architecture robust and scalable?",
+      "description": "Assess whether Redux implementation follows modern patterns with Redux Toolkit, proper slice organization, and async thunk handling. Check if middleware setup includes proper debugging tools, persistence layer, and normalized state structure. Deduct 5 points if using legacy Redux patterns, 3 points if state normalization is poor. Full score requires RTK Query integration, proper error handling, and optimistic updates.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust and error-resilient?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as API failures, network interruption, invalid user inputs, route errors, etc.) and provide friendly error boundaries and recovery mechanisms. Code with strong robustness should include proper loading states, error boundaries, and graceful degradation, giving 10 points. If the robustness is average, give 5 points, and if no error handling is implemented, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there innovative backend management features that enhance productivity?",
+      "description": "Check whether the code includes valuable features that improve admin efficiency (e.g., 1. Advanced data table with virtual scrolling 2. Real-time dashboard with WebSocket updates 3. Drag-and-drop form builder 4. Advanced search with filters 5. Bulk operations with progress tracking). Add 2 points for each well-implemented innovative feature (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant or unnecessary implementations?",
+      "description": "Strictly check three types of redundancy: 1. Duplicate component implementations (e.g., multiple table components with similar functionality) 2. Unused dependencies or features unrelated to backend management 3. Over-engineered solutions that complicate simple tasks. Deduct 3 points for each redundancy found, and directly deduct 10 points if core admin functionalities are hindered by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code demonstrate high engineering standards?",
+      "description": "Review modular architecture (proper separation of components, services, and utilities), TypeScript usage, testing implementation, and build optimization. Deduct 5 points if TypeScript types are poorly defined or any type is overused; deduct 5 points if no testing strategy is implemented; deduct 5 points if build optimization and code splitting are not configured. Full score requires comprehensive engineering practices.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional admin dashboard standards?",
+      "description": "Evaluate whether the design follows modern admin interface principles: 1) Consistent color scheme with proper contrast ratios 2) Logical information hierarchy and spacing (following 8px grid system) 3) Professional typography with readable font sizes (≥14px for body text, proper line heights). Deduct 3 points for each cluttered interface section, 5 points for poor color contrast or accessibility issues, and 5 points for inconsistent spacing or typography. Full score requires polished, professional appearance.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are interactions smooth with appropriate feedback mechanisms?",
+      "description": "Judge whether the user interactions provide appropriate feedback: 1) Button clicks and form submissions have immediate visual feedback ≤100ms 2) Loading states and transitions are smooth (300-500ms duration) 3) Navigation and state changes provide clear visual cues. Deduct 5 points for each interaction without proper feedback, 3 points for jerky animations or transitions, and 5 points for unclear navigation flow. Full score requires seamless, intuitive user experience.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}