@getollie/cli 0.0.1

package/library/other-mobile_application_development/android-wechat-multi-instance-app-uniapp.json

@@ -0,0 +1,68 @@
+{
+  "index": 915,
+  "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. Write an Android WeChat multi-instance app using uni-app in HBuilderX, with properly closed tags, all contained in a single folder.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the WeChat multi-instance functionality correctly implemented?",
+      "description": "Review whether the code properly implements the core multi-instance functionality, allowing users to run multiple WeChat accounts simultaneously. Check if the app uses appropriate isolation mechanisms (WebViews, separate storage spaces, or virtualization techniques) to keep instances separated. Score 0 if multi-instance functionality is not implemented, 5 if basic instance switching is available but with limitations, 10 if full isolation with proper state management is achieved.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the uni-app framework correctly utilized for cross-platform compatibility?",
+      "description": "Evaluate whether the code properly uses uni-app components and APIs instead of platform-specific code. Check if conditional compilation is used where necessary for Android-specific features. Deduct 5 points if platform-specific code is used where uni-app alternatives exist, 3 points if conditional compilation is missing for critical Android features, and 2 points if HBuilderX-specific optimizations are not leveraged.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the project structure organized within a single folder as required?",
+      "description": "Check if the entire application is contained within a single folder with proper organization (pages, components, static assets, etc.). Review whether the manifest.json, pages.json, and main.js files are correctly configured. Deduct 5 points for improper project structure that would prevent HBuilderX compilation, 3 points for missing configuration files, and 2 points for inefficient resource organization.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the app handle WeChat authentication and session management properly?",
+      "description": "Assess whether the code handles WeChat authentication for multiple accounts, including login flows, session persistence, and token refreshing. Check if security measures are in place for storing sensitive data. Deduct 5 points if authentication is not implemented, 3 points if session persistence is missing, and 3 points if there's no secure storage for tokens.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as login failures, network interruptions, permission denials, 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. Customizable themes per instance 2. Message notification filtering by instance 3. Quick switching gesture controls). 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 storage mechanisms for the same data) 2. Function modules unrelated to WeChat multi-instance functionality 3. Fancy effects that affect performance (e.g., unnecessary 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/storage layers), component reusability, and build process optimization. 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 app's performance optimization is inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (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) Instance switching response time ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual indication of active instance. Deduct 5 points for each operation without feedback, 3 points for visual stuttering during animations, and 5 points for confusing navigation between instances. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Mobile Application Development",
+  "difficulty": "medium"
+}

package/library/other-mobile_development/android-webview-vue2-scanning-functionality.json

@@ -0,0 +1,68 @@
+{
+  "index": 445,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Complete code for implementing a scanning functionality in an Android WebView embedded with a Vue 2 project.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the WebView initialization and configuration properly implemented?",
+      "description": "Check if the Android WebView is correctly initialized with proper settings for JavaScript, DOM storage, and file access. Verify if security settings are configured (e.g., setAllowFileAccess, setAllowContentAccess). Deduct 5 points for missing essential configurations that enable Vue.js to work properly; deduct 3 points if security best practices are not followed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the native-to-JavaScript bridge properly implemented?",
+      "description": "Evaluate if a JavaScript interface is added to the WebView using addJavascriptInterface() with proper annotation (@JavascriptInterface). Check if the communication channel between native Android and Vue.js is established with proper error handling and type safety. Deduct 5 points if the bridge is not implemented; deduct 3 points if security measures (like input validation) are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the scanning functionality correctly implemented and integrated with Vue?",
+      "description": "Review the scanning implementation (camera access, barcode/QR detection) and its integration with Vue.js. Verify if permissions are properly requested (CAMERA permission), scanner initialization, result handling, and passing data back to Vue. Deduct 5 points if scanning doesn't work; deduct 3 points if the Vue component doesn't properly handle scan results. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper error handling for scanning scenarios?",
+      "description": "Check if the code handles potential errors like camera unavailability, permission denial, scan failures, or invalid scan content. Verify if proper feedback is provided to the user in case of errors. Deduct 3 points for each unhandled error scenario; deduct 5 points if the app crashes on common errors. 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 WebView loading errors, memory constraints, process lifecycle changes during scanning) 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. Customizable scan overlay 2. Multi-format scanning support 3. History of scanned items 4. Scan result processing options). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scanning libraries used simultaneously) 2. Function modules unrelated to scanning (e.g., unnecessary analytics) 3. Fancy effects that affect scanning performance (e.g., excessive animations during scanning). 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 scanning logic from UI/WebView interactions), error handling patterns, and resource management. Deduct 5 points if memory leaks are found (e.g., not releasing camera resources); deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no proper lifecycle management. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the scanning UI follows modern design principles: 1) Clear scanning area indication 2) Proper camera preview sizing and positioning 3) Professional overlay design with intuitive visual guidance. Deduct 3 points for each confusing UI element, 5 points for poor contrast between scan area and background, and 5 points for illegible text instructions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the scanning experience conforms to human perception characteristics: 1) Immediate camera preview display ≤ 500ms 2) Scan recognition feedback within 100ms 3) Smooth transition between WebView and scanner. Deduct 5 points for noticeable lag when opening scanner, 3 points for jerky camera preview, and 5 points for abrupt transitions between scanning and result display. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Mobile Development",
+  "difficulty": "easy"
+}

package/library/other-mobile_development/xbuild-h5-vue-floating-window-mobile-app.json

@@ -0,0 +1,68 @@
+{
+  "index": 975,
+  "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. Can an xbuild h5 vue project that generates a mobile APP create a floating window that displays over other applications?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the cross-platform capability accurately explained?",
+      "description": "Evaluate whether the response clearly distinguishes between WebView/H5 limitations and native app capabilities regarding system-level floating windows. Check if it explains that Vue-based H5 apps cannot create OS-level floating windows that display over other applications without native integration. Deduct 5 points for ambiguous explanations, 10 points for incorrect technical information about WebView capabilities. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the native bridge integration solution properly implemented?",
+      "description": "Check whether the solution provides a complete native bridge implementation (e.g., using JSBridge, Capacitor, or other native plugins) that connects the Vue application with native functionality required for floating windows. Evaluate if the code includes both the JavaScript interface and corresponding native code (Java/Kotlin for Android, Swift/Objective-C for iOS). Score 0 if missing entirely, 5 for partial implementation, and 10 for complete implementation with proper documentation.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is a viable alternative solution proposed for H5 constraints?",
+      "description": "Assess whether practical alternatives are provided given H5 limitations, such as in-app floating components, PWA notification techniques, or hybrid approaches. Evaluate the practicality and implementation completeness of these alternatives. Score 0 if no alternatives are provided, 5 for conceptual alternatives without implementation, and 10 for fully implemented alternatives with code examples.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are permission requirements and platform differences clearly addressed?",
+      "description": "Review whether the response accurately outlines the permission requirements for floating windows across different platforms (especially Android's SYSTEM_ALERT_WINDOW permission), including code snippets for requesting these permissions. Evaluate explanation of iOS limitations and workarounds. Deduct 3 points for each platform with missing permission handling, and 5 points for incorrect permission information. 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 permission denials, API version compatibility issues, application lifecycle events, 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. Adaptive floating window behavior based on user context 2. Gesture-based controls for the floating window 3. Smart positioning to avoid keyboard/UI overlaps). 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 window creation methods) 2. Function modules unrelated to floating windows (e.g., unnecessary analytics) 3. Performance-heavy effects that aren't essential. 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 UI/logic/platform-specific code), reusability of components, and proper error handling. 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 platform-specific code is not properly isolated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the floating window interface meet professional design standards?",
+      "description": "Evaluate whether the floating window design follows mobile UI principles: 1) Appropriate size and positioning (not blocking critical content) 2) Clear visual hierarchy with proper contrast 3) Touch-friendly target sizes (minimum 44px). Deduct 3 points for each usability issue, 5 points for poor visibility/contrast, and 5 points for designs that don't account for different screen sizes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the floating window interactions are fluid and intuitive: 1) Drag-and-drop responsiveness within 50ms 2) Smooth transitions when showing/hiding (animation duration 200-300ms) 3) Clear visual feedback for all interactions. Deduct 5 points for laggy animations, 3 points for missing interaction states, and 5 points for unintuitive gesture controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Mobile Development",
+  "difficulty": "easy"
+}

package/library/other-mobile_measurement_app/flutter-app-measure-distance-image-photo.json

@@ -0,0 +1,68 @@
+{
+  "index": 757,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration. Develop a Flutter app that can measure the actual distance between two points in an image through taking a photo.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core image capture functionality properly implemented?",
+      "description": "Check whether the code properly integrates Flutter's camera API to capture high-quality images, with proper permissions handling, preview display, and image storage. The implementation should include error handling for camera unavailability scenarios. Score 0 if camera functionality is missing, 5 if basic functionality exists but with issues, and 10 if fully implemented with proper error handling and optimization for different device capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the distance measurement algorithm accurate and efficient?",
+      "description": "Evaluate whether the app uses an appropriate algorithm for calculating real-world distances from image pixels. Check if it implements either a reference object method (comparing to known-size objects) or camera parameters-based calculation (using focal length and sensor data). The algorithm should account for perspective distortion. Deduct 5 points if calculations are mathematically unsound, 3 points if the method requires complex manual calibration, and 2 points if accuracy significantly deteriorates at different distances. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the calibration system well-designed and user-friendly?",
+      "description": "Assess the calibration mechanism that establishes the pixel-to-real-world conversion ratio. An effective system should guide users through a simple calibration process (e.g., placing a reference object of known dimensions), store calibration data, and allow recalibration. Deduct 3 points for each missing component: guided calibration UI, persistent calibration storage, or recalibration option. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the point selection interface provide precise control?",
+      "description": "Review the interface for selecting measurement points on the image. Evaluate the precision controls (e.g., zooming capability for pixel-level selection, draggable points with visual feedback, undo/redo functionality). The interface should handle edge cases like selecting points near the image boundaries. Deduct 3 points for each missing precision feature and 5 points if points cannot be adjusted after initial placement. 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 low-light conditions, blurry images, out-of-memory errors, permission denials, 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. AR visualization of measurements 2. Automatic detection of common objects for reference 3. Batch measurement of multiple distances 4. 3D depth estimation using multiple angles). 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 image processing libraries doing the same job) 2. Function modules unrelated to distance measurement (e.g., unnecessary social sharing features) 3. Fancy effects that affect performance (e.g., excessive animations slowing down the measurement process). 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/data layers using proper Flutter architecture patterns like BLoC, Provider, or Riverpod), 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 Flutter Material/Cupertino design 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, appropriate line heights). Deduct 3 points for each cluttered screen layout, 5 points for inconsistent UI elements, and 5 points for poor accessibility features (e.g., small touch targets, low contrast). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the app performance meets high standards: 1) Responsive UI with no frame drops during transitions 2) Camera preview renders at 30+ FPS 3) Image processing calculations don't block the main UI thread. Deduct 5 points for visible stuttering during point selection, 3 points for delayed feedback when adjusting measurements, and 5 points for ANR (Application Not Responding) events during image processing. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Mobile Measurement App",
+  "difficulty": "hard"
+}

package/library/other-music_player/online-music-player-with-search-and-controls.json

@@ -0,0 +1,68 @@
+{
+  "index": 577,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable and can be displayed. Create an online music player that allows users to search for songs and play them. The player should display song titles, artists, and album covers. It should support play, pause, previous, and next functions, and include a volume control slider.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the music player's core playback functionality fully implemented?",
+      "description": "Evaluate whether the code implements essential music playback controls (play, pause, previous, next) using HTML5 audio API or similar. Check if the player handles audio events properly (ended, timeupdate, loadedmetadata). Score 0 if core playback is missing, 5 if basic playback works but lacks proper event handling, and 10 if all playback functions work seamlessly with proper state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the song search functionality properly implemented?",
+      "description": "Check whether the search functionality connects to a music API (like Spotify, Last.fm, or a mock API) with proper error handling and loading states. Verify if search results display relevant information (title, artist, album) and if pagination/infinite scrolling is implemented for large result sets. Deduct 5 points if the search lacks filtering options, and 3 points if there's no feedback during search operations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the music metadata display complete and accurate?",
+      "description": "Assess if the player displays song titles, artists, and album covers as specified. Check if metadata is properly fetched and displayed for the currently playing song and in search results. Verify the handling of missing metadata (e.g., using placeholders for missing album art). Deduct 3 points for each missing metadata type, and 2 points if metadata isn't updated when songs change. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the volume control slider correctly implemented?",
+      "description": "Evaluate the volume control implementation, checking for smooth volume adjustment, visual feedback, and proper connection to the audio API. Verify if the volume state persists between songs and if a mute toggle is available. Deduct 5 points if volume changes are not reflected in real-time, and 3 points if the slider lacks proper visual indicators. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network errors during search or playback, missing audio files, API limitations) 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. Visualizer for audio frequencies 2. Lyrics display with time synchronization 3. Playlist creation and management 4. Cross-fade between tracks). 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 volume control mechanisms) 2. Function modules unrelated to music playback (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations that impact 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 audio handling/UI/API services), 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 music player UI principles: 1) Harmonious color matching suitable for long viewing sessions 2) Proper layout with clear hierarchy between playback controls, track info, and search results 3) Professional typography with adequate contrast for readability. Deduct 3 points for each cluttered section, 5 points for poor color combinations, and 5 points for inconsistent spacing/alignment. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects enhance the music experience: 1) Responsive playback controls with < 100ms feedback 2) Smooth transitions between search, selection, and playback states 3) Progress bar that updates in real-time and allows seeking. Deduct 5 points for laggy playback controls, 3 points for jarring transitions between player states, and 5 points for non-interactive or jumpy progress indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Music Player",
+  "difficulty": "medium"
+}

package/library/other-productivity_scheduling/online-scheduling-tool-with-calendar-and-sync.json

@@ -0,0 +1,68 @@
+{
+  "index": 526,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code in your responses. Develop an online scheduling tool where users can add, edit, and delete events in a calendar view. The tool should support day, week, and month view switching, event recurrence settings, reminder functionality, and a search feature to quickly find specific events. User data should be able to synchronize across different devices.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the calendar view system fully implemented?",
+      "description": "Review whether the code accurately implements day/week/month view switching through HTML/JavaScript, and whether it includes proper date navigation, grid layout rendering, and event positioning calculations. Check if timezone handling is implemented and if the calendar correctly displays events across different time periods. Score 0 if core calendar rendering is not implemented, 5 if only basic month view is working, and 10 if all three views are fully functional with smooth transitions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the event management functionality complete?",
+      "description": "Evaluate whether the code implements comprehensive CRUD operations for events including add/edit/delete with form validation, drag-and-drop rescheduling, event recurrence patterns (daily/weekly/monthly/yearly), and exception handling for recurring events. Check if event data structure supports all required fields (title, description, start/end time, recurrence rules, reminders). Deduct 5 points if recurrence logic is missing, 3 points if drag-and-drop is not implemented. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the reminder system and search functionality implemented?",
+      "description": "Check whether the reminder system uses appropriate browser APIs (Notification API, Service Workers) with proper permission handling and scheduling mechanisms. Evaluate search functionality including text search across event titles/descriptions, date range filtering, and real-time search suggestions. Deduct 5 points if notifications don't work properly, 3 points if search is limited to exact matches only, 2 points if no search result highlighting. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is cross-device data synchronization properly designed?",
+      "description": "Evaluate whether the synchronization mechanism includes proper data persistence (localStorage/IndexedDB), conflict resolution strategies for concurrent edits, and real-time sync capabilities (WebSocket/Server-Sent Events). Check if offline functionality is supported with proper sync when connection is restored. Deduct 5 points if no real-time sync is implemented, 3 points if conflict resolution is missing, 5 points if offline mode is not supported. 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 date inputs, network interruption, browser storage limits, concurrent editing conflicts, 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. Smart scheduling suggestions based on user patterns 2. Integration with external calendar services (Google Calendar, Outlook) 3. Collaborative scheduling with invitation system 4. AI-powered event categorization 5. Weather integration for outdoor events). 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 date picker implementations coexisting) 2. Function modules unrelated to scheduling (e.g., built-in games or social media feeds) 3. Fancy effects that affect performance (e.g., excessive animations or heavy graphics). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core scheduling 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 calendar logic/view components/data layer), component reusability, state management patterns, and build process automation. Deduct 5 points if global state pollution is found or proper architecture patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no bundling/minification process is implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the calendar design follows modern UI principles: 1) Clean and readable date grid layout with proper contrast ratios 2) Consistent color coding system for different event types 3) Professional typography (calendar dates clearly readable, event text ≥ 12px) 4) Responsive design that works on mobile devices. Deduct 3 points for each cramped calendar cell, 5 points for poor color accessibility, and 5 points for non-responsive layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the calendar interactions conform to user expectations: 1) View switching animations ≤ 300ms 2) Event creation/editing modal appears within 100ms 3) Drag-and-drop operations provide clear visual feedback 4) Date navigation is intuitive with proper loading states 5) Touch gestures work properly on mobile devices. Deduct 5 points for each laggy interaction, 3 points for missing hover/focus states, and 5 points for confusing navigation patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Productivity/Scheduling",
+  "difficulty": "hard"
+}

package/library/other-programming_consultation/python-backend-frontend-code-expert-responses.json

@@ -0,0 +1,68 @@
+{
+  "index": 1488,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code demonstrations when possible. Offer detailed solutions and code that implement both backend and frontend using Python.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Python backend architecture properly implemented?",
+      "description": "Review whether the code includes a well-structured backend framework (Flask/Django/FastAPI) with proper routing, middleware, database integration, and API endpoints. Check for implementation of authentication, session management, and data validation. Score 0 if no backend framework is used, 5 if basic routing is implemented without proper structure, and 10 if a complete MVC/MVT pattern with proper separation of concerns is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the frontend-backend integration seamless?",
+      "description": "Evaluate whether the Python backend properly serves frontend assets and provides RESTful/GraphQL APIs. Check for proper HTTP status codes, JSON response formatting, CORS handling, and error propagation from backend to frontend. Deduct 5 points if API responses lack proper error handling, 3 points if CORS is not configured, and 2 points if HTTP status codes are inconsistent. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the data persistence and database integration robust?",
+      "description": "Check whether the Python backend implements proper database operations using ORM (SQLAlchemy/Django ORM) or raw SQL with connection pooling. Evaluate migration scripts, data validation, transaction handling, and backup mechanisms. Deduct 5 points if no ORM is used without justification, 3 points if database connections are not properly managed, and 2 points if no data validation is implemented. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are Python best practices and performance optimizations implemented?",
+      "description": "Assess whether the code follows Python PEP 8 standards, implements proper async/await patterns where needed, uses appropriate data structures, and includes caching mechanisms. Check for memory management, query optimization, and scalability considerations. Deduct 5 points if no async patterns are used for I/O operations, 3 points if inefficient algorithms are used, and 2 points if PEP 8 standards are not followed. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as database connection failures, invalid user input, file system errors, network timeouts, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include try-catch blocks, input validation, logging, and graceful degradation. Give 10 points if fully implemented with comprehensive exception handling, 5 points if basic error handling exists, and 0 points if no exceptions are handled.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time data streaming with WebSockets 2. AI-powered recommendations or automation 3. Advanced data visualization with interactive charts 4. Progressive Web App features). 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 authentication systems coexisting) 2. Function modules unrelated to the core purpose 3. Over-engineered solutions that add unnecessary complexity. 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 (proper package structure, separation of models/views/controllers), unit test coverage, virtual environment setup, requirements.txt, and deployment configuration. Deduct 5 points if no package structure is implemented; deduct 5 points if code duplication rate exceeds 30%; deduct 5 points if no dependency management or testing framework is included. 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) 4) Responsive design implementation. Deduct 3 points for each crowded visual element, 5 points for glaring color combinations, and 5 points for chaotic text-image layout. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance 4) Loading states for async operations 5) Form validation feedback. Deduct 5 points for each operation without feedback, 3 points for visual after-images during interactions, and 5 points for hard-to-find key function buttons. Full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Programming Consultation",
+  "difficulty": "medium"
+}

package/library/other-security_tools/network-security-scanner-vulnerability-detection.json

@@ -0,0 +1,68 @@
+{
+  "index": 649,
+  "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 whenever possible. Build a network security scanner that can detect common website security vulnerabilities such as XSS, CSRF, SQL injection, and other risks. Scanning results should be displayed by severity level (high, medium, low risk) and provide detailed vulnerability descriptions and remediation suggestions. The scanner should support scan history records and scheduled automatic scanning functionality.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core vulnerability detection engine fully implemented?",
+      "description": "Review whether the code accurately implements detection algorithms for XSS, CSRF, SQL injection, and other common vulnerabilities. Check if the scanner includes proper payload injection, response analysis, and pattern matching mechanisms. Score 0 if core detection logic is missing, 5 if only basic vulnerability checks are implemented, and 10 if comprehensive detection covers all major OWASP Top 10 vulnerabilities with accurate identification.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the network scanning and crawling mechanism properly designed?",
+      "description": "Evaluate whether the implementation includes efficient web crawling with proper HTTP request handling, cookie management, and session tracking. Check for rate limiting, concurrent request management, and robots.txt compliance. Deduct 5 points if no rate limiting is implemented, and 3 points if the scanner doesn't handle JavaScript-rendered content. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the severity classification and risk assessment system accurate?",
+      "description": "Check whether the code implements a comprehensive risk scoring algorithm that properly categorizes vulnerabilities into high, medium, and low severity levels based on CVSS standards or similar frameworks. Evaluate if the assessment considers exploitability, impact, and environmental factors. Deduct 5 points if severity levels are arbitrarily assigned without proper scoring methodology. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are scan history and scheduled scanning features fully functional?",
+      "description": "Verify whether the system includes persistent storage for scan results, historical data comparison, and trend analysis. Check if scheduled scanning supports cron-like configurations, proper job queuing, and failure recovery mechanisms. Deduct 5 points if data persistence is not implemented, and 3 points if the scheduling system lacks error handling. Give 10 points if fully implemented with comprehensive reporting capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network timeouts, malformed responses, target server errors, rate limiting, etc.) and provide appropriate error handling and recovery mechanisms. Code with strong robustness should effectively handle edge cases including DNS resolution failures, SSL certificate issues, and unexpected server responses, giving 10 points. If 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 advanced features that enhance security scanning capabilities (e.g., 1. Machine learning-based anomaly detection 2. Interactive vulnerability exploitation proof-of-concept 3. Integration with threat intelligence feeds 4. Automated penetration testing workflows). 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 scanning functions (e.g., multiple XSS detection engines coexisting) 2. Function modules unrelated to security scanning (e.g., built-in web server for non-scanning purposes) 3. Resource-intensive features that slow down scanning (e.g., unnecessary GUI animations during scanning). Deduct 3 points for each redundancy found, and directly deduct 10 points if core scanning 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 scanning engine/reporting/scheduling components), security considerations in code design, and proper configuration management. Deduct 5 points if sensitive data is hardcoded or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no input validation or output sanitization is implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional security tool design standards?",
+      "description": "Evaluate whether the dashboard design follows security industry standards: 1) Clear severity color coding (red for high, yellow for medium, green for low risk) 2) Proper data visualization with charts and graphs 3) Professional layout with adequate whitespace and readable typography (body font ≥ 14px, line height ≥ 1.5). Deduct 3 points for each confusing visual element, 5 points for poor color contrast affecting readability, and 5 points for cluttered information presentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the scanning workflow and user interaction smooth and intuitive?",
+      "description": "Judge whether the scanning process provides clear user feedback: 1) Real-time scanning progress indicators 2) Responsive controls with feedback delay ≤ 100ms 3) Clear navigation between scan results and detailed vulnerability information 4) Intuitive export and reporting functions. Deduct 5 points for each operation without proper feedback, 3 points for confusing navigation flow, and 5 points for hard-to-access critical functions like vulnerability details or remediation guides. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Security Tools",
+  "difficulty": "medium"
+}