@getollie/cli 0.0.4 → 0.2.0

package/library/management_systems-frontend_backend_platforms/vue2-mobile-desktop-system-page.json

@@ -1,68 +0,0 @@
-{
-  "index": 798,
-  "question": "You are a code expert. Please utilize your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Write a system page similar to a mobile phone desktop using Vue 2.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the mobile phone desktop UI layout properly implemented?",
-      "description": "Evaluate if the code implements a grid-based app icon layout with proper spacing and alignment. Check if the UI includes status bar elements (time, battery, signal), app icons with labels, and a dock/favorites bar at the bottom. Score 0 if no desktop layout is present, 5 points for basic grid layout, 10 points for complete desktop metaphor including status bar and dock.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are core mobile desktop interactions implemented?",
-      "description": "Review if the code implements interactions like app launching (click to open), long-press for edit mode (app rearrangement, deletion, or widgets), swipe gestures for page navigation, and possibly a notification dropdown. Deduct 3 points if long-press functionality is missing, 3 points if swipe navigation is absent, and 4 points if there's no visual feedback on interactions. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is proper component architecture used following Vue 2 best practices?",
-      "description": "Check if the code properly utilizes Vue 2 component structure with single-file components (.vue files), props validation, emit events for child-parent communication, and computed properties/watchers where appropriate. Evaluate the use of Vue lifecycle hooks. Deduct 3 points for global state without proper management, 3 points for prop drilling beyond 2 levels, and 4 points for not leveraging Vue reactivity system. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the state management approach appropriate for the application?",
-      "description": "Evaluate whether the code uses an appropriate state management approach (local component state, prop passing, or Vuex) based on the complexity. For a desktop system, app data, current page, and UI state should be properly managed. Deduct 5 points if there's no centralized state for app data, 3 points if page state isn't preserved during navigation, and 2 points if UI states aren't reactive. 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 missing app data, icon loading failures, unexpected user interactions) and provide appropriate fallbacks or error handling. Code with strong robustness should validate inputs, handle edge cases, and provide meaningful error messages or recovery mechanisms, giving 10 points. If the robustness is 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. App folder creation and management 2. Widget support with live data 3. Custom themes or wallpaper support). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to open apps) 2. Function modules unrelated to mobile desktop (e.g., built-in games unrelated to the launcher) 3. Fancy effects that affect performance (e.g., excessive animations or transitions). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating UI components from logic), reusable components, code organization, and Vue style guide adherence. Deduct 3 points for inline styles instead of properly scoped CSS, 3 points if code duplication rate is high (over 30%), 2 points if naming conventions are inconsistent, and 2 points if component responsibilities are unclear or mixed. 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 mobile UI principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows consistent principles) 3) Professional typography (readable font sizes, proper contrast). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for inconsistent icon styles or sizes. 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 mobile UX expectations: 1) Touch feedback delay ≤ 100ms 2) Transition animations controlled between 200-350ms 3) Clear visual cues for interactive elements. Deduct 3 points for each interaction without feedback, 3 points for janky animations, 2 points for inconsistent transition effects, and 2 points for non-optimized rendering performance (e.g., not using v-once for static content). Full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "easy"
-}

package/library/management_systems-frontend_backend_platforms/vue3-dynamic-menu-vuex-state-management.json

@@ -1,68 +0,0 @@
-{
-  "index": 1194,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you produce is executable when possible. Please provide a complete program for implementing dynamic menu additions based on different users in Vue 3, using Vuex for state management.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Vue 3 component architecture properly implemented?",
-      "description": "Review whether the code properly leverages Vue 3 Composition API or Options API, with clear separation of concerns between components. Check for proper component hierarchy, reusability patterns, and usage of Vue 3 specific features (e.g., teleport, fragments, multiple v-model). Score 0 if Vue 3 specific syntax is not used correctly, 5 if basic implementation is present but lacks optimization, 10 if implementation follows Vue 3 best practices with proper component design.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Vuex state management correctly implemented for dynamic menu handling?",
-      "description": "Evaluate the Vuex store implementation, focusing on proper state organization, mutations, actions, and getters for menu management. Check if the store correctly handles user permissions and menu configurations. Deduct 5 points if the store structure doesn't follow Vuex best practices, 3 points if actions/mutations are inconsistently used. Ensure proper namespacing for menu-related store modules. Full score requires proper reactivity implementation and optimized state access.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the code implement role-based access control for dynamic menus?",
-      "description": "Check whether the implementation includes proper user role detection and permission verification mechanisms. Evaluate if the solution handles different user types (admin/regular users) with corresponding menu structures. Score 0 if permissions are hardcoded, 5 if basic role checking exists but lacks granularity, 10 if a complete RBAC system is implemented with proper menu filtering based on user permissions.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there an efficient menu data structure design?",
-      "description": "Review the menu data structure for flexibility, performance, and maintainability. Check if it supports nested menus (multi-level), dynamic additions/removals, and menu item properties (icons, badges, etc.). Deduct 5 points if the structure doesn't support nesting beyond 2 levels, 3 points if it lacks metadata support for menu items. Full score requires an optimized structure that balances performance with flexibility.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as missing user permissions, partial menu data, network failure during menu loading, etc.) and provide friendly error handling or fallback mechanisms. Code with strong robustness should handle 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. Menu animations with configurable transitions 2. Intelligent menu collapse based on screen size 3. User-customizable menu ordering/favorites). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant state management (e.g., duplicating menu state in component and Vuex) 2. Function modules unrelated to dynamic menus (e.g., extensive authentication systems) 3. Unnecessary re-renders due to poor state design. 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 (separation of menu logic/UI/state management), type safety (TypeScript usage or JSDoc annotations), and testability. 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 consideration for testing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the menu design follows modern UI principles: 1) Consistent spacing between menu items (8px rule) 2) Proper visual hierarchy for nested menus 3) Appropriate use of icons and typography (menu text should be at least 14px). Deduct 3 points for inconsistent spacing, 5 points for poor visual hierarchy, and 5 points for improper icon/text alignment. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the menu interactions are performant and user-friendly: 1) Menu expansion/collapse animations between 200-300ms 2) Responsive to viewport changes 3) Clear visual feedback for active/hover states. Deduct 5 points for jerky menu transitions, 3 points for poor responsive behavior, and 5 points for missing visual indicators for the current menu item. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "easy"
-}

package/library/management_systems-frontend_backend_platforms/vue3-electron-sqlite-knex-pinia-project.json

@@ -1,68 +0,0 @@
-{
-  "index": 1246,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. This involves coding with the common structure of a Vue 3 project using Electron combined with better-sqlite3 and knex, also utilizing Pinia.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Vue 3 core architecture correctly implemented?",
-      "description": "Review whether the code accurately implements Vue 3 composition API features, including setup(), reactive state management, computed properties, and lifecycle hooks. Evaluate the proper use of ref(), reactive(), computed(), and watch(). Score 0 if Vue 3 specific features are not utilized, 5 if basic implementation exists but with optimization issues, and 10 if all Vue 3 best practices are followed with proper component organization.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is Electron integration properly configured and implemented?",
-      "description": "Check if the Electron main and renderer processes are correctly set up with proper IPC communication between them. Evaluate security considerations like contextIsolation and nodeIntegration settings. Verify that file system access, native dialogs, and window management are correctly implemented. Deduct 5 points if process separation is poor, 3 points if security best practices are ignored, and 2 points if native OS integration is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is SQLite database integration with better-sqlite3 and knex properly implemented?",
-      "description": "Evaluate whether database connections, migrations, and queries are properly implemented using better-sqlite3 and knex. Check for transaction support, proper error handling, and connection pool management. Assess if query builders are used instead of raw SQL where appropriate. Deduct 5 points if no migrations exist, 3 points if transactions are not used for critical operations, and 5 points if SQL injection vulnerabilities exist. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is Pinia state management effectively implemented?",
-      "description": "Analyze if Pinia stores are properly structured with state, getters, and actions. Check for proper store modularization, composition, and persistence handling. Evaluate if stores interact correctly with Vue components and avoid anti-patterns. Deduct 3 points if store composition is missing, 5 points if state mutations occur outside actions, and 5 points if stores are overly complex or redundant. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as database connection failures, IPC errors, file system permission issues, 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. Cross-platform file drag-and-drop support 2. Automatic database backup and version control 3. Live data synchronization between multiple app instances). 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 state management solutions coexisting) 2. Function modules unrelated to the core application (e.g., unused libraries) 3. Fancy effects that affect performance (e.g., excessive animations or transitions). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating business logic/UI components/data access 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 or lacks proper configuration for Electron. 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) Database operations don't block the UI thread 3) Clear visual loading states during async operations. Deduct 5 points for each operation without feedback, 3 points for UI freezes during database operations, and 5 points for missing transitions between major view changes. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "medium"
-}

package/library/management_systems-frontend_backend_platforms/vue3-element-plus-project-generation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1685,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code examples when possible. https://www.sowoll.com/#/dashboard Connect to generate a Vue3 + Vue3 + Element Plus project",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Vue3 project setup correctly implemented?",
-      "description": "Check if the code includes proper Vue3 initialization using createApp, proper configuration of Vue Router, and correct loading of Element Plus. Verify that the package.json includes the correct dependencies (vue@^3.x, element-plus, vue-router@^4.x), and that vite.config.js or vue.config.js is properly set up. Score 0 if Vue3 is not correctly configured, 5 if basic setup exists but is incomplete, and 10 if full configuration with proper imports, plugin registration, and environment variables is present.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is Element Plus properly integrated and configured?",
-      "description": "Evaluate whether Element Plus components are properly imported (either globally or on-demand with auto imports), theme customization is implemented, and icon libraries are correctly set up. Check if CSS imports for Element Plus are correctly placed in main.js or index.html. Deduct 5 points if the importing strategy leads to bundle bloat, 3 points if theme configuration is missing, and 2 points if icon setup is incorrect. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the dashboard layout properly implemented?",
-      "description": "Review whether the dashboard layout uses appropriate Element Plus components (such as el-container, el-header, el-aside, el-main) and proper responsive design. Check if the sidebar menu is collapsible and if the layout adapts to different screen sizes. Score 0 if no dashboard layout is implemented, 5 if basic layout exists but lacks responsiveness, and 10 if a fully responsive, well-structured dashboard with proper navigation components is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is proper state management implemented for the dashboard?",
-      "description": "Assess whether the code implements proper state management with Vue3's Composition API (ref, reactive), Pinia, or Vuex. Check for separation of concerns between views and state, and verify that dashboard data is properly reactive. Deduct 5 points if global state is mismanaged, 3 points if props/emits are improperly used, and 5 points if reactivity isn't properly leveraged. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as API failures, loading states, form validation errors) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include try/catch blocks, error boundaries, and loading indicators. Give 10 points for comprehensive error handling and input validation, 5 points if basic error handling exists, and 0 points if exceptions are not handled at all.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dark/light theme toggle 2. Custom dashboard layout saving 3. Interactive data visualizations 4. Keyboard shortcuts for common operations). 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 component registrations or imports 2. Feature modules unrelated to the dashboard context 3. Heavy animations or effects that affect performance. 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 component composition (single-responsibility components), file structure organization, code style consistency, and build process configuration. Deduct 5 points if component coupling is too high; deduct 5 points if naming conventions are inconsistent; deduct 5 points if no ESLint/Prettier configuration is present. 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) Consistent use of Element Plus design language 2) Proper whitespace and component spacing 3) Professional typography with consistent font hierarchy. Deduct 3 points for each inconsistent UI element, 5 points for misaligned components, and 5 points for inconsistent use of Element Plus styling. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the interactions conform to best practices: 1) Appropriate loading indicators for async operations 2) Smooth transitions between routes 3) Feedback for user actions within 100ms. Deduct 5 points for missing loading states during data fetching, 3 points for abrupt page transitions, and 5 points for unresponsive UI during heavy operations. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "medium"
-}

package/library/management_systems-frontend_backend_platforms/vue3-ts-pinia-nested-routing-backend-menu.json

@@ -1,68 +0,0 @@
-{
-  "index": 1659,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable when possible. Vue3 TS Pinia nested routing backend-returned menu",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Vue 3 setup with TypeScript correctly implemented?",
-      "description": "Assess if the Vue 3 application is properly initialized with TypeScript support. Check for proper tsconfig.json configuration, correct component typing (defineComponent, defineProps, defineEmits with proper types), and appropriate type declarations. Score 0 if TypeScript is not properly integrated, 5 if basic TypeScript is used but with any/unknown types, and 10 if strict type checking is enabled with comprehensive custom types and interfaces.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is Pinia state management effectively implemented?",
-      "description": "Evaluate the Pinia store implementation for menu state management. Check for proper store definition with typed state, getters, and actions. Verify if the store correctly handles menu data persistence, loading states, and error handling. Deduct 5 points if the store doesn't use TypeScript interfaces, 3 points if actions don't handle async operations properly, and 2 points if getters lack memoization where appropriate. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the nested routing system correctly implemented?",
-      "description": "Examine the Vue Router configuration for handling nested routes dynamically generated from backend menu data. Check for proper route transformation logic, lazy-loading implementation, route guards for authentication, and correct handling of route parameters. Deduct 5 points if the dynamic route generation doesn't handle nested children properly, 3 points if route meta information is missing, and 2 points if navigation guards aren't implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the backend menu integration properly implemented?",
-      "description": "Review the API integration for fetching menu data from the backend. Check for proper HTTP client setup (Axios/Fetch), typed response handling, error handling with retry mechanisms, data transformation to match front-end requirements, and caching strategies. Deduct 3 points for missing error handling, 3 points for improper response typing, and 4 points for lacking interceptors or request/response transformation. 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 backend API failures, malformed menu data, permission changes during runtime, 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. Menu item drag-and-drop reordering 2. Progressive loading for large menu structures 3. Smart breadcrumb navigation with history 4. Contextual menu adaptation based on user behavior). 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 menu state tracking mechanisms coexisting) 2. Function modules unrelated to menu and routing (e.g., built-in analytics that should be separated) 3. Over-engineered solutions that impact performance (e.g., excessive recursive menu processing). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating API/store/components/types), unit test coverage for critical menu transformation logic, and build process optimization. Deduct 5 points if global state pollution is found or composition API isn't used effectively; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no code splitting for routes. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the menu UI follows modern design principles: 1) Harmonious color matching for active/hover/default states 2) Proper menu item spacing and hierarchy visualization 3) Consistent typography system for menu items with proper truncation. Deduct 3 points for inconsistent menu item styling, 5 points for poor visual hierarchy indication, and 5 points for menu components that don't adapt to different screen sizes. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the menu interactions conform to user expectations: 1) Menu expansion/collapse animations under 300ms 2) Smooth route transitions with proper loading indicators 3) Visual feedback for menu interaction states. Deduct 5 points for menu items without hover/active states, 3 points for jarring page transitions between routes, and 5 points for menu interactions that cause layout shifts. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "medium"
-}

package/library/management_systems-frontend_backend_platforms/vue3-typescript-bpmn-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1170,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that any code you generate is executable. Vue3 setup with TypeScript, implementing BPMN 2.0",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the BPMN 2.0 core modeling functionality implemented?",
-      "description": "Evaluate whether the Vue3 + TypeScript implementation correctly handles the core BPMN 2.0 elements (tasks, gateways, events, sequence flows, etc.) and their properties. Check if the elements maintain proper BPMN 2.0 compliance and semantics according to the OMG specification. Score 0 if basic elements are missing, 5 if implementation is incomplete, 10 if full BPMN 2.0 element coverage is provided.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the BPMN XML import/export functionality properly implemented?",
-      "description": "Verify if the code can correctly parse standard BPMN 2.0 XML files and generate valid BPMN XML that adheres to the specification. Test with sample files to check if all diagram elements and their attributes are preserved during import/export cycles. Deduct 5 points if XML namespaces are improperly handled, 3 points if non-standard extensions aren't properly managed. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the Vue3 Composition API correctly utilized?",
-      "description": "Assess whether the code properly leverages Vue3's Composition API with setup() function, reactive/ref utilities, lifecycle hooks, and proper TypeScript integration. Check for proper component organization, avoiding unnecessary component rendering, and appropriate use of provide/inject for deep component communication. Deduct 5 points for incorrect reactivity implementation, 3 points for improper TypeScript type definitions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the implementation include proper BPMN interaction patterns?",
-      "description": "Review whether the implementation supports standard BPMN interaction patterns such as drag-and-drop creation of elements, context menus for property editing, connection handling between elements, and resizing/repositioning capabilities. Check if the diagram interaction follows BPMN modeling tool conventions. Deduct 5 points if interaction feels clunky or unintuitive, 3 points if standard keyboard shortcuts are 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 malformed BPMN XML, invalid user inputs, overlapping elements, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should prevent diagram corruption and data loss. Give 10 points if exceptional cases are handled comprehensively, 5 points if basic error handling exists, and 0 points if exceptions are unhandled.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the implementation includes innovative features beyond standard BPMN modeling (e.g., 1. Real-time collaborative editing 2. Advanced validation and simulation capabilities 3. Custom theme support with live preview). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Duplicate functionality in different components 2. Feature bloat unrelated to BPMN modeling 3. Over-engineered solutions that could be simplified. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code interferes with core BPMN functionality or significantly impacts performance.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review the TypeScript type definitions, interface consistency, component architecture, and build configuration. Check for proper separation of concerns between rendering, business logic, and data management. Deduct 5 points if 'any' type is overused; deduct 5 points if component composition is poor; deduct 5 points if the build process lacks optimization for production. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the BPMN editor UI follows modern design principles: 1) Consistent visual hierarchy and information architecture 2) Intuitive toolbar and sidebar organization 3) Clear visual distinction between different BPMN element types. Deduct 3 points for cluttered workspace, 5 points for poor element visualization, and 5 points for inconsistent styling between editor components. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the BPMN editor performs efficiently with large diagrams: 1) Element rendering/manipulation feels responsive even with 50+ nodes 2) Smooth zooming and panning without visual glitches 3) Proper loading states for async operations. Deduct 5 points for noticeable lag when editing complex diagrams, 3 points for jerky animations during element interactions, and 5 points for poor mobile/touch device support. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "easy"
-}

package/library/management_systems-frontend_backend_platforms/vue3-vite-data-display-video-stats-backend.json

@@ -1,68 +0,0 @@
-{
-  "index": 1164,
-  "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. Help me write a Vue 3 + Vite data display video playback statistics backend.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Vue 3 + Vite project structure correctly configured?",
-      "description": "Review whether the project structure follows Vue 3 + Vite best practices, including proper directory organization (components, views, assets, etc.), correct configuration of vite.config.js, and proper implementation of Vue 3 features (Composition API, <script setup>, etc.). Score 0 if the basic structure is incorrect, 5 if the structure is correct but missing optimization configurations, and 10 if the project structure is fully optimized with proper tree-shaking, code splitting, and asset handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the video playback functionality properly implemented?",
-      "description": "Evaluate the implementation of video playback features including play/pause controls, seeking functionality, volume control, and playback rate adjustment. Check if the HTML5 video API is properly utilized with Vue reactivity. Deduct 3 points if seeking functionality is missing, 3 points if playback controls are incomplete, and 5 points if the video player doesn't handle different formats or errors. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the data collection and statistics system comprehensive?",
-      "description": "Check whether the system collects comprehensive playback statistics including: watch time, play/pause events, drop-off points, completion rates, and interaction hotspots. Verify if the implementation includes throttling/debouncing for event handling and batched server updates to prevent overloading. Deduct 3 points if the collected data lacks granularity, 4 points if there's no optimization for data transmission, and 5 points if the statistics aren't properly structured for backend storage. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the backend integration include proper API design and state management?",
-      "description": "Evaluate if the backend integration follows RESTful or GraphQL principles, includes proper error handling, authentication mechanisms, and uses efficient state management (Pinia/Vuex). Check whether the API communication includes request/response interceptors, request cancellation for abandoned queries, and retry mechanisms. Deduct 5 points for missing authentication, 3 points for poor error handling, and 3 points for inefficient state management. 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 video loading failures, network interruptions, API 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 content recommendations 2. Interactive heatmaps for viewer engagement 3. Multi-angle viewing options 4. Automated chapter detection). 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 state management solutions coexisting) 2. Function modules unrelated to video statistics (e.g., unnecessary social features) 3. Fancy effects that affect performance (e.g., excessive animations that impact video playback). 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/business logic/API services), test coverage (unit tests with Vitest/Jest), and build process automation (CI/CD integration). Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Management Systems-Frontend/Backend Platforms",
-  "difficulty": "hard"
-}

package/library/management_systems-frontend_backend_platforms/vuetify-windows-diary-software-mood-thoughts.json

@@ -1,68 +0,0 @@
-{
-  "index": 1427,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable. I want to use Vuetify components to implement a diary software for Windows. It should be able to record daily moods, thoughts, etc.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core diary functionality fully implemented?",
-      "description": "Review whether the code accurately implements essential diary features: entry creation, editing, deletion, and viewing. Check if date-based organization is implemented, and if entries can store mood and thought data separately. Score 0 if basic CRUD operations are missing, 5 if basic operations exist but lack organization features, and 10 if all core diary functions are completely implemented with proper data validation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Vuetify implementation correctly utilized?",
-      "description": "Evaluate whether the code properly incorporates Vuetify components (v-card, v-text-field, v-date-picker, etc.) following Vue best practices. Check if the component hierarchy makes sense and if Vuetify's grid system is used for responsive layouts. Deduct 3 points if Vuetify's theming is not utilized, 5 points if components are used incorrectly or inconsistently, and 5 points if the responsive design is broken. Give full score if Vuetify is leveraged comprehensively and correctly.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the Windows-specific functionality properly implemented?",
-      "description": "Check whether the code includes Windows-specific features like local file system integration, desktop notifications, start-up configuration, and Windows UI/UX patterns. Verify if Electron or similar technology is used for Windows desktop integration. Deduct 5 points if there's no way to save data locally, 5 points if Windows-native features are absent, and 3 points if the app doesn't follow Windows design guidelines. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the mood tracking and visualization feature effectively implemented?",
-      "description": "Assess whether the code includes mood tracking functionality with appropriate UI elements (e.g., emoji selectors, mood sliders) and visualization components (charts/graphs) to display mood trends over time. Check if mood data is properly stored and can be filtered/searched. Deduct 5 points if visualization is missing, 3 points if mood tracking is too simplistic, and 3 points if historical mood data analysis is not available. 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 data corruption, offline usage, unexpected input, 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 mood analysis 2. Automated tagging system 3. Customizable templates for different entry types 4. Media attachment support for photos/audio). 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 save entries) 2. Function modules unrelated to diary keeping (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., excessive 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 data/UI/service layers), state management implementation, and build process configuration. Deduct 5 points if global state pollution is found or Vue composition API/Options API is used inconsistently; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no build configuration for Windows packaging (using electron-builder or similar). 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 (following Vuetify's material design palette) 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 diary entry and navigation. 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": "easy"
-}