@getollie/cli 0.0.1

package/library/other-software_development/eclipse-plugin-xml-to-awt-swing-shapes.json

@@ -0,0 +1,68 @@
+{
+  "index": 360,
+  "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. How can I use Eclipse plugins to transform XML into shapes displayed through AWT and Swing?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is XML parsing implementation complete?",
+      "description": "Check whether the code correctly implements XML parsing using standard libraries such as DOM, SAX, or JAXB. Score 0 if parsing is not implemented, 5 if only basic parsing without error handling is implemented, and 10 if comprehensive parsing with proper validation, error handling, and support for namespaces is provided.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Eclipse plugin architecture properly implemented?",
+      "description": "Evaluate whether the code correctly implements Eclipse plugin architecture including plugin.xml configuration, extension points, and lifecycle methods. Deduct 5 points if plugin manifest is incomplete, 3 points if dependency management is missing, and 3 points if the plugin doesn't integrate with Eclipse workbench. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is XML-to-shape transformation logic complete?",
+      "description": "Review whether the code contains a comprehensive mapping system between XML elements/attributes and graphical shapes/properties. Check if the transformation handles nested elements, coordinates, color schemes, and scaling. Score 0 if transformation logic is missing, 5 if only basic shapes are supported, and 10 if advanced transformations including complex paths and custom shapes are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is AWT/Swing rendering implementation complete?",
+      "description": "Check if the code properly implements AWT/Swing components for rendering the shapes, including proper use of Graphics2D, paintComponent, and event handling. Verify if double buffering is used to prevent flickering. Deduct 3 points if rendering optimization is missing, 3 points if custom painting doesn't follow Java2D best practices, and 5 points if the rendering doesn't handle window resizing properly.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed XML, out-of-bounds coordinates, invalid shape definitions, 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. Live preview of XML changes 2. Visual XML editor with drag-and-drop 3. Shape animation capabilities 4. Export to SVG/PNG 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 XML parsers) 2. Function modules unrelated to XML transformation (e.g., unnecessary networking components) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating XML parsing/transformation/rendering layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast shape redrawing, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

package/library/other-software_development/generate-executable-ai-code-workflow.json

@@ -0,0 +1,68 @@
+{
+  "index": 1490,
+  "question": "You are a code expert. Please utilize your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable whenever possible. This includes webpage addresses, plugin loading, AI-based code node implementation workflow according to specific goals (task breakdowns including loading, extraction, parsing, storage, etc.), execution and debugging.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the code execution context properly defined and implemented?",
+      "description": "Evaluate whether the code clearly defines its execution environment (browser, Node.js, specific frameworks) with appropriate initialization. Check if dependencies are explicitly declared with version control. Verify if the execution flow is clearly structured with proper entry points. Score 0 if execution context is undefined, 5 if basic context is provided but lacks configuration details, and 10 if comprehensive environment setup with fallback mechanisms is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the AI-based code workflow properly structured with clear task breakdowns?",
+      "description": "Assess whether the code implements a complete AI workflow with clearly defined stages (loading, extraction, parsing, storage). Check if each stage has appropriate error handling and progress monitoring. Validate that the workflow components are loosely coupled for maintainability. Deduct 5 points if key stages are missing, 3 points if the workflow lacks proper transitions between stages, and 2 points if success/failure states aren't clearly defined. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are data loading and extraction mechanisms effectively implemented?",
+      "description": "Review the implementation of data acquisition processes, including external API calls, file system operations, or web scraping techniques. Verify support for different data formats (JSON, CSV, XML) and asynchronous loading patterns. Check for rate limiting, caching, and retry mechanisms. Score 0 if loading functionality is absent, 5 if basic loading exists without optimization, and 10 if comprehensive data acquisition with fallback strategies is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the parsing and storage logic comprehensive and efficient?",
+      "description": "Evaluate data parsing algorithms for accuracy and efficiency. Check for proper data validation, normalization, and transformation processes. Verify if storage mechanisms include appropriate indexing, query optimization, and data persistence strategies. Deduct 5 points if parsing logic contains edge case vulnerabilities, 3 points if storage doesn't implement proper transaction handling, and 2 points if data integrity checks are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common exceptions and edge cases (network failures, malformed inputs, resource limitations) with appropriate error recovery mechanisms. Check for input validation, defensive programming practices, and graceful degradation. Look for diagnostic logging and monitoring capabilities. Deduct 3 points for each unhandled error scenario, 5 points for absence of timeout mechanisms, and 5 points if error messages aren't user-friendly. The full score is 10 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 algorithm selection based on data characteristics 2. Progressive loading with visual feedback 3. Context-aware error suggestions). Evaluate implementation quality and practical utility of innovative 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. Duplicate implementation of similar functionality (e.g., multiple HTTP client wrappers) 2. Unnecessary processing steps that don't contribute to the core workflow 3. Over-engineered solutions for simple problems. Deduct 3 points for each redundancy found, and directly deduct 10 points if core functionality is obscured by unnecessary complexity.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design, separation of concerns, and adherence to design patterns. Check for consistent naming conventions, code documentation, and test coverage. Evaluate configuration management and environment separation. Deduct 5 points if global state is mismanaged, 5 points if the code duplication rate exceeds 30%, and 5 points if there's no automated testing strategy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional standards?",
+      "description": "Evaluate whether any UI components follow modern design principles: 1) Consistent visual hierarchy with proper use of whitespace 2) Responsive design that adapts to different screen sizes 3) Accessibility compliance (WCAG standards, proper contrast ratios, screen reader support). Deduct 3 points for inconsistent visual patterns, 5 points for non-responsive layouts, and 5 points for major accessibility violations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the execution and debugging experience well-designed?",
+      "description": "Judge the quality of runtime feedback and debugging capabilities: 1) Informative progress indicators for long-running operations 2) Meaningful error messages with actionable suggestions 3) Integrated debugging tools or hooks for external monitoring. Deduct 5 points for silent failures without explanation, 3 points for ambiguous progress states, and 5 points for absence of debugging entry points. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Software Development",
+  "difficulty": "medium"
+}

package/library/other-tool_recommendations/ai-tool-mini-program-ui-code-generation.json

@@ -0,0 +1,68 @@
+{
+  "index": 402,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code when possible. Which AI tool is currently capable of designing mini-program UI and generating code?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the AI tool evaluation comprehensive and accurate?",
+      "description": "Review whether the response covers mainstream AI tools for mini-program development (such as GitHub Copilot, Cursor, v0.dev, Figma AI, Sketch2Code, etc.) and provides accurate capability assessments. Check if the evaluation includes both UI design and code generation capabilities. Score 0 if only 1-2 tools are mentioned, 5 if 3-5 tools are covered but lack detail, and 10 if comprehensive coverage with accurate capability analysis is provided.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are practical code examples provided for each recommended tool?",
+      "description": "Evaluate whether executable mini-program code samples are provided for each AI tool mentioned, demonstrating their actual code generation capabilities. Examples should include WeChat mini-program (.wxml, .wxss, .js files) or other platform equivalents. Deduct 3 points for each tool mentioned without a working code example. Full score requires all recommended tools to have corresponding executable demonstrations.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the UI design capability assessment detailed and demonstrable?",
+      "description": "Check whether the response includes actual UI design outputs from the mentioned AI tools, with visual comparisons and design quality analysis. Should cover design-to-code workflow efficiency, component library integration, and responsive design capabilities. Deduct 5 points if no visual examples are provided, 3 points if design quality metrics are missing. Full score requires comprehensive UI capability demonstration with screenshots or mockups.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are tool limitations and comparison criteria clearly established?",
+      "description": "Evaluate whether the response provides honest assessment of each tool's limitations, pricing models, learning curves, integration complexity, and suitable use cases. Should include comparative analysis matrix covering factors like accuracy, speed, platform support, and customization capabilities. Deduct 5 points if limitations are not mentioned, 3 points if comparison lacks objective criteria. Full score requires balanced pros/cons analysis with clear selection guidance.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the provided code examples can handle common abnormal situations (such as API failures, network interruption, invalid user input, platform compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases in mini-program environments, 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 insights or cutting-edge developments highlighted?",
+      "description": "Check whether the response includes emerging trends in AI-powered development (e.g., 1. Multi-modal design-to-code conversion 2. Real-time collaborative AI coding 3. Cross-platform code generation optimization 4. AI-powered accessibility compliance checking). Add 3 points for each practical innovative insight provided with concrete examples (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant or outdated recommendations?",
+      "description": "Strictly check three types of issues: 1. Outdated tools that are no longer maintained or effective 2. Redundant recommendations of similar tools without clear differentiation 3. Off-topic suggestions not related to mini-program development. Deduct 3 points for each redundant or outdated recommendation found, and directly deduct 10 points if core mini-program development requirements are not addressed.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the response demonstrate engineering quality?",
+      "description": "Review whether code examples follow mini-program best practices including proper file structure, component modularity, performance optimization, and platform-specific guidelines. Deduct 5 points if code lacks proper organization or violates platform conventions; deduct 5 points if performance considerations are ignored; deduct 5 points if security best practices are not followed. Full score requires professional-grade code structure.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Do the UI examples meet professional design standards?",
+      "description": "Evaluate whether UI examples or screenshots follow modern mini-program design principles: 1) Consistent with platform design guidelines (WeChat/Alipay design systems) 2) Proper component spacing and hierarchy 3) Mobile-first responsive design considerations 4) Accessibility compliance. Deduct 3 points for each design guideline violation, 5 points for poor visual hierarchy, and 5 points for mobile usability issues. Full score requires platform-compliant professional design quality.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the workflow integration seamless and practical?",
+      "description": "Judge whether the recommended tools integrate smoothly into real development workflows: 1) Clear setup and integration instructions 2) Compatibility with existing development environments 3) Efficient design-to-development handoff processes 4) Team collaboration capabilities. Deduct 5 points for each missing integration step, 3 points for unclear documentation, and 5 points if workflow efficiency gains are not demonstrated. Full score requires complete end-to-end workflow demonstration.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Tool Recommendations",
+  "difficulty": "hard"
+}

package/library/other-transit_system/public-transit-system-frontend.json

@@ -0,0 +1,68 @@
+{
+  "index": 1769,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you create is executable for display. Create a front-end page for a public transit system.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the transit map visualization properly implemented?",
+      "description": "Review whether the code implements a clear and accurate transit map using HTML/SVG/Canvas, with proper representation of routes, stations, and transfer points. Score 0 if no map is implemented, 5 if a basic static map is provided, and 10 if an interactive map with zoom/pan functionality is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the route planning and search functionality complete?",
+      "description": "Evaluate whether users can search for routes between stations with options for fastest/shortest routes, departure times, and transit preferences. Check if the algorithm accounts for transfer times and service frequencies. Deduct 5 points if only basic point-to-point routing exists, 3 points if time-based planning is missing. Give 10 points if advanced features like multi-criteria optimization are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is real-time transit information handling implemented?",
+      "description": "Check whether the code implements mechanisms for displaying real-time arrival/departure information, service disruptions, and delays. Verify if data refresh mechanisms and API integration points exist. Score 0 if no real-time features exist, 5 if basic updates are implemented, and 10 if comprehensive real-time functionality with fallback mechanisms is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the responsive design properly implemented for multiple devices?",
+      "description": "Assess whether the transit page adapts appropriately to different screen sizes (desktop, tablet, mobile) using responsive design techniques. Check for media queries, flexible layouts, and touch-friendly controls on mobile. Deduct 5 points if the layout breaks on certain devices, and 3 points if mobile-specific optimizations are missing. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network failures, invalid user inputs, missing transit data, API errors) 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. Augmented reality station finder 2. Personalized travel statistics/carbon footprint 3. Accessibility features for visually impaired users). 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 map libraries loaded) 2. Function modules unrelated to public transit (e.g., weather forecasts unrelated to travel) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow page loading). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI components, data services, and state management), code organization, and performance 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 no performance optimization techniques are implemented. 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 transit UI principles: 1) Clear visual hierarchy highlighting important information 2) Proper color coding for different transit lines 3) Typography that ensures readability of schedules and station names (minimum 14px font). Deduct 3 points for cluttered information display, 5 points for poor color contrast affecting readability, and 5 points for inconsistent design elements. 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) Route selection feedback delay ≤ 100ms 2) Smooth transitions when switching between views 3) Clear loading indicators for data retrieval operations. Deduct 5 points for each operation without feedback, 3 points for janky animations, and 5 points for confusing navigation patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Transit System",
+  "difficulty": "medium"
+}

package/library/other-travel_management/vue3-personalized-travel-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 1648,
+  "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 whenever possible. Nowadays, people often use holidays to travel to various places. A personalized travel system can help people manage their travel activities, offering features such as travel destination recommendations, travel route planning, tourist attraction queries, and travel diary sharing.\n\nBefore traveling: First select travel destinations based on popularity, reviews, and personal interests;\nDuring travel: Within attractions (including schools), plan optimal visiting routes based on sightseeing goals, provide attraction information and location queries while touring;\nAfter traveling: Generate travel diaries based on photos taken and travel experiences.\n\nAccording to these requirements, please build a Vue3-based website framework that implements the above features. Include the App.vue and main.js files, and list all additional dependencies that need to be installed.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Vue3 project architecture properly implemented?",
+      "description": "Review whether the code correctly implements a Vue3 project structure with App.vue, main.js, and necessary component organization. Check for the use of Vue3's Composition API, proper component hierarchy, and adherence to Vue3 best practices. Score 0 if the basic Vue3 setup is missing, 5 if implemented but with structural issues, 10 if fully implemented with clean architecture.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the pre-travel destination selection features fully implemented?",
+      "description": "Evaluate whether the code includes functionality for users to browse and select travel destinations based on popularity, reviews, and personal interests. Check for filtering mechanisms, recommendation algorithms, and data visualization of destination metrics. Deduct 3 points if personalization features are missing, 4 points if there's no review system, and 3 points if destination comparison functionality is absent. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the during-travel route planning and attraction query system implemented?",
+      "description": "Assess if the system provides optimal route planning based on user preferences and sightseeing goals. Check for map integration, geolocation functionality, and real-time attraction information queries. Deduct 5 points if route optimization is missing, 3 points if there's no location-based search, and 2 points if attraction details are incomplete. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the post-travel diary generation feature properly implemented?",
+      "description": "Check whether the application provides functionality to generate travel diaries from photos and experiences. Verify the presence of photo uploading, diary editing tools, and sharing mechanisms. Deduct 4 points if photo management is missing, 3 points if diary templates are not available, and 3 points if sharing options are limited. 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 failures, invalid user inputs, missing data, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-powered travel recommendations 2. Augmented reality for attraction information 3. Automated itinerary optimization based on weather forecasts). 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 map providers serving the same purpose) 2. Function modules unrelated to travel planning (e.g., a built-in generic game) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the application). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating API calls/state management/UI components), test coverage, and build process optimization. Deduct 5 points if global state is poorly managed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the dependency management is chaotic or outdated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Travel Management",
+  "difficulty": "medium"
+}

package/library/other-ui_ux_design_standards/ten-lines-at-a-glance-display-standard.json

@@ -0,0 +1,68 @@
+{
+  "index": 854,
+  "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 when presented. \"Ten Lines at a Glance\" Training\nBased on the title, generate a standard for an app's subtitle display that allows viewing ten lines at a glance.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the subtitle display system properly designed?",
+      "description": "Review whether the code implements a proper subtitle display mechanism that shows exactly 10 lines at a time. Check if it handles text wrapping correctly, accounts for different screen sizes, and maintains consistent line height. Score 0 if the display doesn't show 10 lines, 5 if it shows 10 lines but with inconsistent spacing or formatting, and 10 if it perfectly displays 10 lines with proper formatting and responsiveness.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is text rendering optimization implemented?",
+      "description": "Evaluate whether the code includes techniques for efficient text rendering such as text virtualization, canvas-based rendering, or optimized DOM manipulation for smooth scrolling through subtitles. Check if the implementation prevents layout thrashing when updating lines. Deduct 5 points if no optimization is present, 3 points if basic optimization exists but performance still suffers under load. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a proper timing synchronization mechanism?",
+      "description": "Check if the subtitle system includes synchronization with media timing (video/audio) through either timestamp-based or duration-based approaches. Verify that there's a mechanism to adjust subtitle display based on playback speed changes. Deduct 5 points if subtitles aren't properly synchronized, 3 points if synchronization works only at normal speed. Award 10 points for a comprehensive solution with frame-accurate timing.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the implementation handle various subtitle formats and languages?",
+      "description": "Assess whether the code supports common subtitle formats (SRT, WebVTT, etc.) and handles different languages properly, including right-to-left text, vertical text, and complex scripts. Check if it correctly manages Unicode characters and text that requires special rendering. Deduct 5 points if only one format is supported, 3 points if language support is limited. 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 malformed subtitle files, missing timing information, overlapping time codes, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic font sizing based on content importance 2. Color-coded speaker identification 3. Smooth transition animations between subtitle changes). 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 subtitle parsing mechanisms 2. Unnecessary rendering loops or DOM manipulations 3. Overly complex animations that could impact performance or readability. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core subtitle display functionality is compromised by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating subtitle parsing/rendering/synchronization), 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 subtitle display follows modern design principles: 1) Appropriate contrast ratio between text and background (minimum 4.5:1) 2) Proper typography with adequate spacing between lines (1.2-1.5× line height) 3) Consistent margins and padding around the subtitle area. Deduct 3 points for poor contrast, 5 points for illegible font choices, and 5 points for inconsistent spacing or alignment. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the subtitle transitions conform to human perception characteristics: 1) Subtitles appear and disappear without jarring 2) Smooth scrolling if content changes while maintaining readability 3) Proper focus handling for accessibility. Deduct 5 points for abrupt transitions between subtitles, 3 points for stuttering during scrolling, and 5 points for lack of user controls for subtitle display preferences. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-UI/UX Design Standards",
+  "difficulty": "hard"
+}

package/library/other-video_streaming_application/winui3-ffmpeg-rtsp-video-stream-display.json

@@ -0,0 +1,68 @@
+{
+  "index": 209,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for demonstration. I am developing a WinUI3 application and need to use ffmpeg.autogen to pull RTSP streams and display the video stream on an Image control, without audio. The video delay needs to be strictly controlled, expected to be within 200ms. Please provide a detailed design solution and output the complete code for direct use.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the RTSP stream pulling mechanism correctly implemented?",
+      "description": "Review whether the code correctly initializes ffmpeg.autogen libraries, sets up the RTSP connection with appropriate parameters (TCP transport preferred over UDP for stability), and includes proper error handling for stream connection failures. Check if the code includes low-latency configurations like setting 'rtsp_flags' to 'prefer_tcp' and using 'fflags' with 'nobuffer' and 'flush_packets' options. Score 0 if ffmpeg initialization is missing, 5 if basic RTSP connection works without optimizations, and 10 if all low-latency configurations are properly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the video frame processing pipeline optimized for low latency?",
+      "description": "Evaluate if the decoding pipeline minimizes buffering, uses direct memory access when possible, and implements frame skipping for maintaining real-time playback. Check if the solution correctly handles I-frames vs P-frames, avoids unnecessary frame copying, and implements a proper synchronization mechanism. Deduct 5 points if frame buffering exceeds 2 frames, 3 points if frame conversion adds unnecessary overhead, and 2 points if timestamp management is improperly implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is WinUI3 rendering properly integrated with ffmpeg's output?",
+      "description": "Check if the solution properly converts decoded frames to a format compatible with WinUI3's Image control (like SoftwareBitmap or WriteableBitmap), handles UI thread synchronization properly, and optimizes the rendering process. Verify that the solution includes proper disposal of unmanaged resources and doesn't leak memory during frame conversions. Deduct 5 points if UI thread synchronization is incorrect, 3 points if frame conversion is inefficient, and 2 points if memory management is improper. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is latency measurement and control implemented effectively?",
+      "description": "Evaluate if the solution includes accurate methods to measure end-to-end latency, from capture to display, and implements strategies to maintain it under 200ms. Check for frame timestamp comparison, queue management techniques, or adaptive frame dropping algorithms. Deduct 5 points if no latency measurement is implemented, 3 points if measurements are inaccurate, and 2 points if there's no mechanism to maintain latency targets. Give 10 points for a comprehensive solution with adaptive control mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruptions, malformed packets, codec errors, etc.) and provide friendly error prompts or recovery mechanisms. Check if the solution implements connection retry logic, graceful degradation for poor network conditions, and proper cleanup on errors. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time latency display on the UI 2. Network quality indicator 3. Dynamic quality adjustment based on connection speed 4. Multiple stream support with thumbnail previews). 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 initialization of ffmpeg components 2. Unnecessary processing steps in the video pipeline that add latency 3. UI elements or threading models that don't contribute to the core functionality or 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 stream acquisition/decoding/rendering layers), error handling coverage, and resource management. 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 proper resource disposal is not implemented. Check if the solution follows RAII principles for unmanaged resources. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the WinUI3 interface follows modern design principles: 1) Proper layout using Grid/StackPanel with appropriate margins 2) High-contrast controls for stream control and status indicators 3) Responsive design that handles window resizing gracefully. Deduct 3 points for each poorly implemented UI element, 5 points for inconsistent styling, and 5 points for poor layout adaptation to different window sizes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the application provides responsive controls: 1) Stream connect/disconnect response ≤ 100ms 2) Clear visual indicators for buffering states 3) Proper error message display with actionable information. Deduct 5 points for operations without feedback, 3 points for UI freezes during stream operations, and 5 points for confusing state representations. Check if the solution implements proper UI thread marshaling to prevent freezing. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Video Streaming Application",
+  "difficulty": "hard"
+}

package/library/other-web_component_development/vue-virtual-table-component-development.json

@@ -0,0 +1,68 @@
+{
+  "index": 263,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure to ensure that any code you generate is executable and demonstrable. Vue virtual table component development.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the virtual table core virtualization logic properly implemented?",
+      "description": "Review whether the code correctly implements row/column virtualization by rendering only visible elements within the viewport. Check for proper calculation of visible range based on scroll position, container dimensions, and item heights. Score 0 if virtualization is absent, 5 if only basic virtualization exists, and 10 if both horizontal and vertical virtualization with variable height/width support are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the scroll performance optimization comprehensive?",
+      "description": "Evaluate whether the implementation uses proper optimization techniques such as: requestAnimationFrame for scroll handling, debouncing of expensive calculations, DOM recycling patterns, and efficient style updates. Check for frame rate maintenance under heavy load (should maintain 60fps with 10,000+ rows). Deduct 5 points if scroll jank occurs with large datasets, 3 points if memory usage grows significantly during scrolling.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the essential table features complete?",
+      "description": "Assess the implementation of core table functionalities: column sorting, filtering, resizing, reordering, fixed headers/columns, cell formatting, and nested data support. Each missing essential feature deducts 2 points. The component should maintain virtualization effectiveness while supporting these features. Deduct 5 points if features break virtualization.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the component API well designed for Vue ecosystem integration?",
+      "description": "Evaluate the component API design including props interface, events emission, slots usage, and Vue lifecycle hooks handling. Verify that the component respects Vue's reactivity system and properly implements v-model/two-way binding where appropriate. Check compatibility with both Vue 2 and Vue 3 or clear documentation about version support. Deduct 5 points for incomplete reactivity, 3 points for poor slot implementation.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common edge cases (empty data sets, dynamic data updates, window resizing, extreme dimensions, etc.) and provides appropriate error boundaries. Check for defensive programming practices around scroll calculations. Deduct 3 points for each unhandled edge case. Code with strong robustness should handle these scenarios gracefully, giving 10 points. If the robustness is average, give 5 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. Progressive loading with placeholders 2. Cell-level animations that maintain performance 3. Context-aware column width optimization 4. Intelligent sticky positioning). 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. Multiple implementations of scrolling logic 2. Features unrelated to table visualization 3. Heavy visual effects that compromise virtualization performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if core virtualization is compromised by unnecessary code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review separation of concerns (data handling, virtualization logic, rendering, event handling), test coverage for core logic, and build configuration. Check for TypeScript type definitions and JSDoc documentation. Deduct 5 points if global state management is chaotic; deduct 5 points if the code has excessive coupling between components; deduct 5 points if there's no build optimization for tree-shaking. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the table design follows modern UI principles: 1) Consistent cell padding and alignment 2) Clear visual hierarchy between header/data rows 3) Proper use of borders and separators 4) Responsive design considerations. Deduct 3 points for inconsistent spacing, 5 points for poor contrast between UI elements, and 5 points for lack of visual feedback on interaction (hover, selection states). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the scrolling behavior feels native and smooth: 1) No visible rendering gaps during fast scrolling 2) Smooth transition when items enter/exit the viewport 3) Proper handling of touch/trackpad inertial scrolling. Deduct 5 points for visible rendering pop-in/flicker, 3 points for scroll position jumping, and 5 points for poor touch device support. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Web Component Development",
+  "difficulty": "medium"
+}