@getollie/cli 0.0.5 → 0.2.0

package/library/other-mobile_app_development/harmonyos-button-navigation-view.json

@@ -1,68 +0,0 @@
-{
-  "index": 404,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and expert responses. Pay attention to ensure that the generated code is executable for demonstration. Add a view to a HarmonyOS page where clicking a button on the view will navigate to another page on the current page.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the HarmonyOS page structure correctly implemented?",
-      "description": "Review whether the code uses proper HarmonyOS framework structure with correct @Entry and @Component decorators, proper lifecycle methods (aboutToAppear, aboutToDisappear), and follows ArkTS syntax standards. Check if the page implements proper state management using @State, @Prop, or @Link decorators. Score 0 if basic page structure is missing, 5 if only basic structure exists without proper state management, and 10 if complete HarmonyOS page architecture is implemented with proper lifecycle and state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the button component and click event handling properly implemented?",
-      "description": "Evaluate whether the Button component is correctly implemented with proper onClick event handler, includes appropriate button styling and accessibility features. Check if the button follows HarmonyOS design guidelines for touch targets (minimum 44vp) and includes proper visual feedback states. Deduct 5 points if onClick handler is missing or incorrect, 3 points if button accessibility is not implemented, and 2 points if visual feedback states are missing. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the page navigation mechanism correctly implemented?",
-      "description": "Check whether the navigation uses proper HarmonyOS router mechanism (router.pushUrl or router.replaceUrl), includes correct page routing configuration, and handles navigation parameters properly. Verify if the target page is properly registered in module.json5 and navigation includes proper error handling. Deduct 5 points if router implementation is incorrect, 3 points if page registration is missing, and 2 points if error handling is not implemented. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the complete navigation lifecycle and data passing implemented?",
-      "description": "Evaluate whether the navigation includes proper data passing between pages using router parameters, implements proper page stack management, and includes back navigation handling. Check if the target page can receive and process passed parameters correctly, and if the navigation maintains proper page lifecycle. Deduct 5 points if data passing is not implemented, 3 points if page stack management is incorrect, and 2 points if back navigation is not handled properly. Give 10 points if fully implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as navigation failures, invalid parameters, page lifecycle errors, memory leaks, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include try-catch blocks for navigation operations and proper error handling. Give 10 points if fully robust, 5 points if average robustness, and 0 points if no exception handling.",
-      "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 HarmonyOS user experience (e.g., 1. Custom page transition animations 2. Gesture-based navigation 3. Dynamic theme adaptation 4. Advanced state preservation during navigation). Add 3 points for each practical innovative feature implemented that leverages HarmonyOS capabilities (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant navigation implementations (e.g., multiple router calls for same action) 2. Unnecessary UI components unrelated to the navigation task 3. Over-complicated animations or effects that don't serve the core functionality. Deduct 3 points for each redundancy found, and directly deduct 10 points if core navigation functionality is interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review HarmonyOS project structure compliance, proper use of ArkTS language features, component modularity, and build configuration. Check if the code follows HarmonyOS coding standards, uses proper import/export statements, and includes appropriate file organization. Deduct 5 points if project structure doesn't follow HarmonyOS standards; deduct 5 points if code organization is poor; deduct 5 points if build configuration is incomplete. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet HarmonyOS design standards?",
-      "description": "Evaluate whether the design follows HarmonyOS design language principles: 1) Proper use of HarmonyOS color system and themes 2) Correct spacing using HarmonyOS grid system (8vp multiples) 3) Appropriate typography following HarmonyOS font specifications 4) Proper component sizing and touch targets (minimum 44vp). Deduct 3 points for each non-compliant visual element, 5 points for inconsistent design language usage, and 5 points for poor accessibility compliance. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the interactions conform to HarmonyOS UX guidelines: 1) Button press feedback ≤ 100ms 2) Page transition animations follow HarmonyOS motion design (300-400ms duration) 3) Proper loading states during navigation 4) Smooth 60fps performance during interactions. Deduct 5 points for each interaction without proper feedback, 3 points for janky animations or transitions, and 5 points for poor performance during navigation. Full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Other-Mobile App Development",
-  "difficulty": "medium"
-}

package/library/other-mobile_app_development/react-native-tableview-like-with-cell-selection.json

@@ -1,68 +0,0 @@
-{
-  "index": 1451,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure that the code you provide is executable and demonstrable. For an iOS native project, please implement a secondary page using React Native that resembles the native tableview, which can scroll up and down and respond to cell selection. Please provide the complete code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is a complete React Native component implemented that resembles iOS UITableView?",
-      "description": "Evaluate whether the code implements a proper React Native component that visually and functionally resembles the native iOS UITableView. Check for proper section headers, row styling, separators, and overall visual fidelity to native iOS components. Score 0 if the component is missing or barely resembles a UITableView, 5 if basic structure is implemented but with visual inconsistencies, and 10 if it's virtually indistinguishable from a native implementation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the implementation handle vertical scrolling properly?",
-      "description": "Verify that the React Native implementation properly handles vertical scrolling with iOS-like momentum, bounce effects, scroll indicators, and pull-to-refresh capabilities. Check if FlatList or ScrollView is configured correctly with appropriate performance optimizations. Deduct 3 points if scrolling performance is poor, 3 points if iOS-specific scroll behaviors are missing, and 5 points if scrolling functionality is broken. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is cell selection implemented with proper visual feedback?",
-      "description": "Examine whether cell selection provides the standard iOS highlight effect, proper onPress handlers, and appropriate visual feedback. Check if selection state is properly managed and if there's a haptic feedback implementation. Deduct 5 points if selection visual effect is missing or incorrect, 3 points if selection callback is not implemented, and 2 points if there's no deselection handling. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the integration between React Native and iOS native properly configured?",
-      "description": "Evaluate if the code includes proper React Native to iOS native bridge configuration, including navigation handling between native screens and React Native views. Check for proper module registration, event handling across the bridge, and configuration of the RCTRootView. Deduct 5 points for missing native module integration, 3 points for improper navigation handling, and 5 points for broken communication between native and React Native. 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 loading failures, network issues, state inconsistencies) and provide friendly error handling. Check for proper componentDidCatch implementations, error boundaries, and fallback UIs. 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. Swipe actions on cells 2. Interactive cell animations 3. Advanced section indexing like in native Contacts app). 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 or component re-rendering 2. Unnecessarily complex animations that affect performance 3. Overuse of third-party libraries for simple tasks. 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 architecture (proper separation of concerns, stateless/stateful components), TypeScript/PropTypes usage, and code organization. Deduct 5 points if there's no component decomposition; deduct 5 points if prop validation is missing; deduct 5 points if styling approach is inconsistent or inline styles are overused. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet iOS design standards?",
-      "description": "Evaluate whether the design follows iOS Human Interface Guidelines: 1) Proper use of system colors 2) Standard font usage (SF Pro or equivalent) 3) Proper margins and layout constraints matching iOS defaults (typically 16pt horizontal margins). Deduct 3 points for each non-iOS-like visual element, 5 points for Android-looking components, and 5 points for improper use of navigation bars or toolbars. 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 iOS interaction standards: 1) Proper cell highlight timings 2) Standard iOS animation durations (typically 0.3s for most transitions) 3) Proper gesture handling that doesn't interfere with native gestures. Deduct 5 points for each janky animation, 3 points for incorrect timing in interactions, and 5 points for gesture conflicts with native iOS gestures. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Other-Mobile App Development",
-  "difficulty": "easy"
-}

package/library/other-mobile_app_development/taro-wechat-code-128-barcode-recognition.json

@@ -1,68 +0,0 @@
-{
-  "index": 1274,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to make the code executable for demonstration purposes. Please use Taro to quickly develop a WeChat Mini Program that can recognize Code 128 barcodes.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Taro environment configured correctly?",
-      "description": "Check whether the code includes proper Taro initialization, with correct dependencies (Taro core, React/Vue binding, WeChat Mini Program adapters) and configuration files (project.config.json, app.config.ts). Verify that the project structure follows Taro conventions and includes appropriate build scripts. Deduct 5 points if essential dependencies are missing, 3 points if configurations are incomplete. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Code 128 barcode recognition algorithm implemented correctly?",
-      "description": "Evaluate the implementation of the Code 128 barcode decoding algorithm: check for proper handling of start/stop characters, checksum validation, and character set switching (Code 128A/B/C). The implementation should handle different barcode densities and have appropriate error correction. Score 10 points for a complete implementation with all Code 128 features, 5 points for basic recognition without full feature support, and 0 points if the core algorithm is missing or fundamentally flawed.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the camera access functionality properly implemented?",
-      "description": "Review whether the code correctly utilizes Taro's camera component or WeChat's camera API to access the device camera. Check for proper permission handling, preview frame rendering, and frame capturing for barcode processing. The implementation should include focus control, flash control options, and proper camera resolution settings for barcode scanning. Deduct 5 points if camera permissions aren't properly handled, 3 points if preview quality is poor. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the image processing pipeline efficient for barcode detection?",
-      "description": "Analyze the image processing approach: check for preprocessing steps (grayscale conversion, binarization, noise reduction), barcode localization algorithms, and optimization techniques. The implementation should handle various lighting conditions and scan angles. Evaluate processing speed and memory efficiency. Score 10 points for a comprehensive pipeline with optimizations, 5 points for basic functionality that works only in ideal conditions, and 0 points if critical processing steps are missing.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as camera permission denial, poor lighting conditions, partial or damaged barcodes, processing timeout) 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. Batch scanning capability 2. History of scanned codes 3. Scanning statistics and analytics 4. Augmented reality overlay for scan guidance). 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 image processing steps that slow down scanning 2. Function modules unrelated to barcode scanning (e.g., unnecessary social sharing features) 3. Heavy visual effects that affect scanning 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 modular design (such as separating camera handling/image processing/UI layers), unit test coverage for algorithm components, 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 WeChat Mini Program 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) Scan feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual scan guidance and feedback. Deduct 5 points for each operation without feedback, 3 points for laggy camera preview during scanning, and 5 points for confusing user interface during the scanning process. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Other-Mobile App Development",
-  "difficulty": "easy"
-}

package/library/other-mobile_app_development/uniapp-vue3-editor-example.json

@@ -1,68 +0,0 @@
-{
-  "index": 405,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and expert responses. Be sure to ensure that the code you generate is executable for demonstration purposes. Provide an example of using an editor in uniapp, using Vue 3 syntax.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is a complete and functional editor component implemented in UniApp with Vue 3?",
-      "description": "Assess whether the code provides a fully functional editor component that works within the UniApp framework using Vue 3 composition API. Check for essential editor features like text input/output, formatting controls, and cursor management. Score 0 if only boilerplate code is provided, 5 points if basic functionality is implemented but lacks key features, 10 points if the editor is fully functional with all core capabilities.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the editor properly integrated with UniApp's cross-platform capabilities?",
-      "description": "Evaluate whether the implementation correctly uses UniApp's APIs and components to ensure cross-platform compatibility (iOS, Android, H5, mini-programs). Check if platform-specific adaptations are handled appropriately. Deduct 3 points if only works on one platform type, deduct 5 points if platform-specific issues aren't addressed at all. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the implementation correctly use Vue 3 composition API features?",
-      "description": "Check if the code properly utilizes Vue 3 composition API (setup(), ref, reactive, computed, watch, lifecycle hooks, etc.) instead of Options API. Assess whether composables are created for reusable functionality. Deduct 5 points if Vue 3 specific features are missing, deduct 3 points if composition API is mixed improperly with Options API. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are editor features like rich text formatting and content management properly implemented?",
-      "description": "Review if the editor includes essential capabilities like text formatting (bold, italic, etc.), media insertion, undo/redo functionality, and content storage/retrieval. Check if the content can be saved and loaded properly. Deduct 3 points for each missing critical feature. 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 input errors, content loading failures, memory management) 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-assisted text completion 2. Collaborative editing capabilities 3. Custom toolbar extensions). 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 text processing utilities that do the same thing) 2. Function modules unrelated to the editor (e.g., built-in calculators, calendars) 3. Fancy effects that affect performance (e.g., excessive animations that slow down editing). 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 editor logic/view/data handling layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the editor UI 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 editor interaction smooth and responsive?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Text input response ≤ 50ms 2) Formatting change transition between 100-300ms 3) Clear visual feedback when applying formatting. Deduct 5 points for each operation without feedback, 3 points for input lag during typing, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Other-Mobile App Development",
-  "difficulty": "easy"
-}

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

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

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

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

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