@getollie/cli 0.0.1

package/library/web_applications-education_learning/react-jupyter-notebook-renderer.json

@@ -0,0 +1,68 @@
+{
+  "index": 1536,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration purposes. Could you write a React page that renders a Jupyter notebook page?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic Jupyter notebook structure properly implemented in React?",
+      "description": "Check if the code implements the core Jupyter notebook components: cells (code, markdown), cell execution counter, toolbar, and menu bar. Score 0 if essential components are missing, 5 if basic components are present but lack proper styling or hierarchy, and 10 if the structure closely resembles an actual Jupyter notebook with proper component organization.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the different cell types (code, markdown, raw) properly implemented with correct rendering?",
+      "description": "Evaluate whether the code implements different cell types with appropriate editors and renderers. Code cells should have syntax highlighting, markdown cells should render formatted text, and there should be UI to switch between cell types. Deduct 3 points if syntax highlighting is missing, 4 points if markdown rendering is incorrect, and 5 points if cell type switching is not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a working code execution simulation mechanism?",
+      "description": "Check if the React implementation includes a mechanism to simulate code execution (even if through mock data or simple JavaScript evaluation). The implementation should show execution status (running/completed), display output (text, graphs, tables), and handle execution errors. Deduct 5 points if execution status indicators are missing, and 5 points if output rendering is not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are cell manipulation functions (add, delete, move, run) implemented?",
+      "description": "Verify if the implementation includes common cell operations like adding new cells, deleting cells, moving cells up/down, and running cells individually or in sequence. Each missing function deducts 2.5 points. Check if keyboard shortcuts are implemented for these operations (an additional 2.5 points for complete shortcuts). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common edge cases (such as invalid cell content, long outputs, rendering errors) and provides appropriate error handling. Code with strong robustness should effectively handle these edge cases, giving 10 points. If error handling is basic, give 5 points, and if no error handling exists, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time collaboration simulation 2. Dark/light theme switching 3. Cell folding/collapsing). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to execute code) 2. Function modules unrelated to Jupyter notebooks (e.g., unrelated dashboard elements) 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 component structure (proper separation of concerns), state management approach, use of React hooks and patterns, and code reusability. Deduct 5 points if global state is poorly managed; deduct 3 points if React anti-patterns are found; deduct 2 points if there's significant code duplication. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the design follows Jupyter's familiar interface standards while maintaining modern UI principles: 1) Proper color scheme matching Jupyter's palette 2) Clear visual hierarchy with consistent spacing 3) Appropriate typography (code vs. text differentiation). Deduct 3 points for each significant deviation from Jupyter's recognizable interface, 4 points for poor visual hierarchy, and 3 points for inconsistent typography. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the interactions match the expected Jupyter experience: 1) Smooth cell focus transitions 2) Appropriate feedback when executing code 3) Intuitive keyboard navigation between cells. Deduct 3 points for laggy cell transitions, 4 points for missing execution feedback, and 3 points for unintuitive keyboard navigation. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "hard"
+}

package/library/web_applications-education_learning/real-time-convertible-bond-market-info-webpage.json

@@ -0,0 +1,68 @@
+{
+  "index": 324,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the generated code is executable for demonstration. Create a small webpage that displays real-time convertible bond market information.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the real-time data fetching mechanism implemented correctly?",
+      "description": "Review if the code implements proper API calls for fetching convertible bond data, includes error handling for API failures, and utilizes appropriate polling intervals or WebSocket connections. Score 0 if there's no real-time data implementation, 5 if basic polling is implemented without error handling, and 10 if it includes proper error handling, connection management, and fallback mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the webpage display all essential convertible bond information?",
+      "description": "Check if the display includes critical bond metrics such as current price, yield to maturity, conversion premium, underlying stock performance, and bond rating. Deduct 2 points for each missing essential data point. The display should also include search/filter capabilities and sorting options. Give 10 points if all essential information is present with proper organization.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there appropriate data visualization for bond performance?",
+      "description": "Evaluate whether the code implements visual elements (charts, graphs) for bond price history, yield curves, or comparison with underlying stocks. Deduct 5 points if there are no visualizations, 3 points if visualizations are present but lack interactivity (zoom, hover details). Give full 10 points if visualizations are interactive, responsive, and professionally rendered.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the code implement alerting or notification features?",
+      "description": "Assess if the webpage includes functionality for price alerts, conversion opportunity notifications, or significant event indicators. Score 0 if no alerting features exist, 5 if basic visual indicators are present without configuration options, and 10 if comprehensive, configurable alert systems are implemented with both visual and audio notifications.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as API failure, data format changes, network interruption, 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. Automated bond recommendation system 2. Market sentiment analysis visualization 3. Customizable dashboard layouts). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to sort the same data) 2. Function modules unrelated to bond markets (e.g., cryptocurrency trackers) 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 data fetching/visualization/user interface layers), code reusability, 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 there's no consideration for performance with large datasets. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the financial data display follows industry design principles: 1) Clear information hierarchy with important metrics emphasized 2) Proper use of color to indicate market movements (e.g., red for down, green for up) 3) Professional typography with adequate contrast ratios. Deduct 3 points for cluttered layouts, 5 points for misleading visual representations of data, and 5 points for poor readability of critical information. 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 financial application standards: 1) Real-time updates without page flicker 2) Smooth transitions for changing data values 3) Clear loading states during data fetching. Deduct 5 points for jarring data refreshes, 3 points for lack of visual feedback during user interactions, and 5 points for confusing navigation between different bond information views. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "hard"
+}

package/library/web_applications-education_learning/recipe-search-system-frontend-backend-java.json

@@ -0,0 +1,68 @@
+{
+  "index": 776,
+  "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 when possible. Hello, I want to create a recipe search system, designing the frontend, backend, and algorithmic models. For the algorithmic models, I'm using Python and already have mature model code. Now I need your help designing the frontend and backend code, with requirements for rapid development and Java as the backend language.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the recipe search frontend interface well designed?",
+      "description": "Review whether the frontend code implements an intuitive and user-friendly interface with proper search inputs, filters (ingredient, cuisine type, preparation time, etc.), and result display. Check for responsive design that works across devices. Score 0 if the interface is not implemented, 5 if only basic search functionality exists, and 10 if the interface includes advanced filtering, auto-suggestions, and a visually appealing recipe card display.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Java backend architecture properly implemented?",
+      "description": "Evaluate the backend architecture for proper API design, RESTful principles, dependency injection, and service layer organization. Check if proper design patterns are used and if the code follows Java best practices. Deduct 5 points if there's no clear separation of concerns, 3 points if error handling is missing, and 3 points if data validation is inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the recipe search algorithm effectively integrated with the backend?",
+      "description": "Check whether the Python algorithmic model is properly integrated with the Java backend (using technologies like REST API, gRPC, or JNI). Verify the integration implementation includes proper serialization/deserialization, error handling, and efficient data transfer. Deduct 5 points if integration is unreliable or inefficient, 3 points if there's no caching mechanism for frequently accessed recipes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the data persistence layer properly designed?",
+      "description": "Evaluate the database schema design for recipe storage, user preferences, and search history. Check for proper indexing to support fast searches, ORM implementation, and query optimization. Deduct 5 points if there's no consideration for recipe metadata (like ingredients, nutritional info), 3 points if there's no transaction management, and 3 points if there's no database migration strategy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid search inputs, API failures, algorithm exceptions, 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. Personalized recipe recommendations 2. Nutritional analysis visualization 3. Interactive cooking steps with timers). 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 search implementations) 2. Function modules unrelated to recipe search (e.g., a built-in weather widget) 3. Fancy effects that affect performance (e.g., excessive animations during recipe display). 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), 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) Search results appear within 300ms 2) Recipe card animations controlled between 300-500ms 3) Clear visual feedback during search operations. Deduct 5 points for each operation without feedback, 3 points for visual stuttering during search result loading, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "medium"
+}

package/library/web_applications-education_learning/runnable-laboratory-website-template.json

@@ -0,0 +1,68 @@
+{
+  "index": 741,
+  "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 for demonstration purposes. Create a runnable laboratory website template.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the laboratory website structure properly implemented?",
+      "description": "Evaluate whether the HTML structure follows semantic markup principles with proper use of <header>, <nav>, <main>, <section>, <footer> tags. Check if the document includes essential meta tags for SEO and responsive design. Deduct 3 points if semantic HTML5 elements are not used; deduct 3 points if the responsive meta viewport tag is missing; deduct 4 points if the document structure is illogical. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the navigation and information architecture well-designed?",
+      "description": "Assess whether the site includes essential laboratory website sections (Home, Research, Team, Publications, Resources, Contact) with logical organization and clear navigation paths. Navigation should be accessible both on desktop and mobile. Deduct 3 points if key sections are missing; deduct 4 points if the navigation is not responsive; deduct 3 points if there's no visual indication of current page. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the website feature research presentation capabilities?",
+      "description": "Check whether the website includes components for showcasing research projects, such as project cards, publication listings, or interactive demonstrations. There should be clear categorization of research areas and filtering capabilities. Deduct 5 points if research presentation is limited to static text; deduct 5 points if there's no visual representation of research data/projects. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there functionality for team member profiles and academic credentials?",
+      "description": "Evaluate if the website includes a team section with proper profile structure (photo, name, position, research interests, contact info, publications links). Check if there's a hierarchical representation of lab leadership, researchers, students, and alumni. Deduct 3 points if profiles lack academic credentials; deduct 4 points if the layout doesn't scale for different team sizes; deduct 3 points if there's no individual profile page template. 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 missing images, varied content lengths, browser compatibility issues, etc.) and provide graceful fallbacks. Check for form validation if contact forms are implemented. Deduct 3 points for each unhandled edge case; deduct 5 points if the site breaks completely on older browsers. 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. Interactive research visualizations 2. Publication citation generator 3. Lab equipment booking system 4. Research timeline). 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 navigation systems) 2. Function modules unrelated to academic/laboratory context 3. Fancy effects that affect performance (e.g., excessive animations that distract from content). 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 layout/components/styles), CSS organization (consistent naming convention, preferably BEM or similar), and JavaScript structure (event delegation, proper module pattern). Deduct 5 points if global CSS/JS pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation of concerns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional academic standards?",
+      "description": "Evaluate whether the design follows professional academic website standards: 1) Clean, credible appearance with appropriate whitespace 2) Academic color scheme (typically institutional colors or conservative palettes) 3) Professional typography (readable fonts, proper hierarchy, line length ≤80 characters). Deduct 3 points for cluttered layouts, 5 points for inappropriate color schemes for academic context, and 5 points for poor typography that reduces readability. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the site accessible and responsive across devices?",
+      "description": "Judge whether the website meets accessibility standards (WCAG) and performs well across device sizes: 1) Proper contrast ratios and focus states 2) Responsive layouts that adapt from mobile to desktop 3) Content readability on all screen sizes. Deduct 4 points for non-responsive layouts; deduct 3 points for each major accessibility violation (missing alt text, keyboard navigation issues); deduct 3 points for poor performance on mobile devices. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}

package/library/web_applications-education_learning/school-network-framework-semantic-ui.json

@@ -0,0 +1,68 @@
+{
+  "index": 1688,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure the code you produce is executable for demonstration. Create a network framework for a school using Semantic UI.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the school network framework architecture comprehensively designed?",
+      "description": "Review whether the code implements a complete school network framework including core modules: user management system (students/teachers/administrators), course management, grade management, and notification system. Check if the framework uses proper MVC/MVVM architecture patterns and includes database schema design. Score 0 if core school modules are missing, 5 if only basic user management is implemented, and 10 if all essential school management modules are fully integrated with proper data relationships.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is Semantic UI properly integrated and utilized?",
+      "description": "Evaluate whether Semantic UI components are correctly implemented including navigation menus, forms, tables, modals, and grid systems. Check if custom CSS properly extends Semantic UI themes without conflicts. Verify responsive design implementation across different screen sizes. Deduct 5 points if Semantic UI components are not properly initialized with JavaScript, and 3 points if responsive breakpoints are not handled correctly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the user authentication and authorization system robust?",
+      "description": "Check whether the framework implements secure login/logout functionality with proper session management and role-based access control (RBAC) for different user types (students, teachers, administrators). Evaluate password hashing, CSRF protection, and input validation. Deduct 5 points if role-based permissions are not properly implemented, and 3 points if session security measures are inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the data management and API integration complete?",
+      "description": "Assess whether the framework includes proper CRUD operations for school entities (users, courses, grades, schedules) with appropriate database connections. Check if RESTful API endpoints are designed with proper HTTP methods and status codes. Evaluate data validation, error handling, and transaction management. Deduct 5 points if database relationships are not properly established, and 3 points if API responses lack proper error handling. Give 10 points if fully implemented with comprehensive data flow.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid user inputs, database connection failures, file upload errors, network timeouts, 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 framework includes surprise features that enhance the school management experience (e.g., 1. Real-time dashboard with analytics 2. Automated email notifications for assignments/grades 3. Calendar integration with Google/Outlook 4. Mobile-responsive progressive web app features). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple user validation logics coexisting) 2. Function modules unrelated to school management (e.g., a built-in games section) 3. Fancy effects that affect performance (e.g., excessive animations on data tables). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core school management functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating business logic/presentation/data layers), code organization, and configuration 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 environment configuration is hardcoded without proper config files. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching consistent with Semantic UI theme (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional typography system (body font size ≥ 14px, line height over 1.5 times) 4) Consistent iconography and proper visual hierarchy. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic layout structure. 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) Form submission feedback delay ≤ 100ms 2) Page transitions and modal animations duration controlled between 300-500ms 3) Clear visual focus guidance for navigation 4) Semantic UI component interactions (dropdowns, accordions, tabs) work smoothly. Deduct 5 points for each operation without feedback, 3 points for visual glitches during component state changes, and 5 points for hard-to-find navigation elements. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "hard"
+}

package/library/web_applications-education_learning/second-grade-multiplication-arithmetic-mini-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 233,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure that the code you generate is executable and can be demonstrated. I am a young teacher teaching second grade (second semester). I now want to develop a mental arithmetic mini-program for second grade (second semester). This mini-program mainly focuses on multiplication tables as its core, then includes some calculations with multiplication and division, as well as fill-in-the-blank exercises for multiplication tables. These could involve not knowing the first multiplicand and having to fill it in to calculate the product, or not knowing the product or multiplicand and having to fill it in. This mental arithmetic program needs to be under my control with certain buttons. These buttons should preferably be displayed in Chinese.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the multiplication table core functionality fully implemented?",
+      "description": "Review whether the code accurately implements the complete multiplication tables (1-9) with proper display and interactions. Check if the program allows students to practice, review, and be tested on the tables. Score 0 if the core functionality is missing, 5 if only basic tables are shown without interaction, and 10 if all multiplication tables are fully interactive with proper learning progression.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the various calculation exercises properly implemented?",
+      "description": "Evaluate whether the code includes different types of exercises: standard multiplication/division calculations, fill-in-the-blank for first multiplicand, fill-in-the-blank for second multiplicand, and fill-in-the-blank for the product. Check if the program generates appropriate difficulty levels for grade 2 students. Deduct 3 points for each missing exercise type. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the teacher control interface comprehensive?",
+      "description": "Check whether the code provides a teacher control panel with proper Chinese-labeled buttons for adjusting difficulty levels, selecting exercise types, tracking student progress, and managing the program flow. The interface should give the teacher full control over the learning experience. Deduct 2 points for each missing essential function. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the program include an appropriate feedback and scoring system?",
+      "description": "Assess whether the code implements immediate feedback for student answers, appropriate encouragement/correction messages, progress tracking, and a scoring system suitable for second-grade students. Check if visual/audio feedback is child-friendly and educational. Deduct 3 points if immediate feedback is missing, 3 points if the scoring system is not grade-appropriate, and 4 points if there's no progress tracking. 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 incorrect inputs, accidental button clicks, interruptions, etc.) and provide child-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 learning experience (e.g., 1. Gamification elements like reward badges 2. Visual multiplication representations 3. Adaptive difficulty that adjusts to student performance). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to practice the same concept) 2. Function modules unrelated to math learning (e.g., unnecessary games) 3. Fancy effects that may distract young learners. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core learning functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/logic/data layers), code readability appropriate for educational software, and maintainability for teacher modifications. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code structure would make it difficult for the teacher to make simple modifications. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet child-friendly design standards?",
+      "description": "Evaluate whether the overall design follows child-friendly principles: 1) Bright but not overwhelming colors 2) Clear, large buttons with Chinese labels 3) Age-appropriate fonts and sizes (≥16px) 4) Simple, uncluttered layout appropriate for 7-8 year olds. Deduct 3 points for each visually confusing element, 5 points for inappropriate color schemes, and 5 points for text that would be difficult for second-graders to read. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction suitable for young children?",
+      "description": "Judge whether the interactions are appropriate for 7-8 year old children: 1) Large, easy-to-tap buttons (at least 44×44px) 2) Forgiving interaction patterns that don't require precise movements 3) Clear visual/audio feedback for each action 4) Appropriate animation speed for children's cognitive abilities. Deduct 5 points for touch targets that are too small, 3 points for complex gestures, and 5 points for confusing navigation. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}

package/library/web_applications-education_learning/seventh-grade-west-asia-southeast-asia-quiz.json

@@ -0,0 +1,68 @@
+{
+  "index": 1402,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Please help me create test questions about West Asia and Southeast Asia suitable for seventh-grade students, along with a random question selection button. Include at least 40 questions.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the quiz system fundamentally implemented?",
+      "description": "Review whether the code accurately implements a basic quiz application with question display, answer selection/submission, and result feedback. Score 0 if there's no quiz functionality, 5 if basic questions are displayed but without answer checking, and 10 if the system includes questions, answer selection, validation, and feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are there at least 40 geographically accurate questions about West Asia and Southeast Asia?",
+      "description": "Check if the code contains at least 40 unique questions specifically about West Asia and Southeast Asia. Questions should be factually accurate and appropriate for seventh-grade students. Deduct 1 point for each question below 40, deduct 5 points if questions aren't focused on the required regions, and deduct 3 points if the difficulty level is clearly inappropriate for seventh-graders. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is a functional random question selection button implemented?",
+      "description": "Evaluate if the code includes a working random question selection mechanism that presents different questions each time it's pressed. Check if the randomization algorithm ensures good distribution and doesn't repeat questions too frequently. Deduct 5 points if randomization is not implemented, deduct 3 points if it works but has noticeable patterns or repetitions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the questions well-structured with proper educational content?",
+      "description": "Assess whether the questions cover appropriate educational content (geography, culture, history, etc.) about West Asia and Southeast Asia. Check for a balanced distribution between regions, difficulty levels, and question types (multiple choice, true/false, etc.). Deduct 3 points for poorly structured questions, 3 points for uneven regional coverage, and 4 points for lack of educational value. 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 unexpected user inputs, browser incompatibilities, 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 learning experience (e.g., 1. Visual maps for context 2. Progress tracking 3. Difficulty adjustment based on performance). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to select random questions) 2. Function modules unrelated to the quiz (e.g., an unrelated game) 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 data/view/control layers), maintainability, and code organization. Deduct 5 points if global variable 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 code lacks comments or is poorly organized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional educational standards?",
+      "description": "Evaluate whether the overall design follows educational design principles: 1) Age-appropriate visual elements for seventh-graders 2) Clear and readable text (font size ≥ 16px, sufficient contrast) 3) Logical layout with intuitive navigation. Deduct 3 points for cluttered layouts, 5 points for poor readability, and 5 points for confusing navigation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and user-friendly?",
+      "description": "Judge whether the interface provides appropriate feedback and guidance: 1) Clear indication of correct/incorrect answers 2) Intuitive navigation between questions 3) Visual feedback for button clicks and selections. Deduct 5 points for each operation without feedback, 3 points for confusing transitions between questions, and 5 points if the random selection button is difficult to locate or use. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}

package/library/web_applications-education_learning/shaanlu-elementary-english-word-quiz.json

@@ -0,0 +1,68 @@
+{
+  "index": 760,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable. Please write a piece of code that can run in a web browser to help elementary school students memorize English words. The textbook used is the Shaanlu version (starting from third grade). The program should allow testing by grade level and semester, include multiple-choice questions where students select English words based on Chinese prompts, or allow typing/spelling words when given Chinese meanings.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the word database and grade-level classification system properly implemented?",
+      "description": "Review whether the code includes a comprehensive vocabulary database for Shaanlu textbook (grades 3-6, two semesters each), with proper data structure design for word storage including Chinese meanings, pronunciations, and difficulty levels. Check if the grade/semester filtering mechanism is accurately implemented. Score 0 if no structured word database exists, 5 if only basic word lists are present without proper classification, and 10 if complete grade-semester hierarchy with accurate Shaanlu vocabulary is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are multiple testing modes (multiple-choice and spelling input) fully functional?",
+      "description": "Evaluate whether both testing modes are properly implemented: 1) Multiple-choice questions with Chinese prompts requiring English word selection 2) Spelling input mode where students type English words based on Chinese meanings. Check answer validation logic, randomization of options, and proper scoring mechanisms. Deduct 5 points if only one mode is implemented, 3 points if answer validation is incomplete. Full score requires both modes working seamlessly with accurate feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the progress tracking and learning analytics system designed effectively?",
+      "description": "Check whether the system tracks student performance including correct/incorrect answers, learning progress per grade level, weak word identification, and study recommendations. Evaluate if local storage or session management is used to maintain learning history. Deduct 5 points if no progress tracking exists, 3 points if only basic scoring is implemented without detailed analytics. Full implementation should include performance dashboards and adaptive difficulty adjustment.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are age-appropriate learning features and gamification elements integrated?",
+      "description": "Assess whether the application includes elementary school-friendly features such as encouraging feedback messages, achievement badges, streak counters, or simple reward systems. Check if the difficulty progression is suitable for young learners and includes hints or learning aids. Score 0 if the interface is purely functional without educational psychology considerations, 5 if basic encouragement features exist, and 10 if comprehensive gamification enhances learning motivation.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust and handles edge cases appropriately?",
+      "description": "Evaluate whether the code can handle common issues such as empty inputs, special characters in spelling mode, browser compatibility problems, data loading failures, and user operation errors. The application should provide clear error messages and graceful degradation. Code with strong robustness should effectively handle these edge cases, 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 innovative educational features that enhance learning experience?",
+      "description": "Check whether the code includes creative features that boost learning effectiveness (e.g., 1. Audio pronunciation playback 2. Visual word association images 3. Spaced repetition algorithm 4. Parent/teacher progress reports 5. Offline mode capability). Add 2-3 points for each practical innovative feature implemented with a maximum of 10 points. Features must be functional, not just decorative.",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant or inappropriate features for the target audience?",
+      "description": "Strictly check for three types of issues: 1) Redundant implementation of similar functions (e.g., multiple scoring systems) 2) Features inappropriate for elementary students (e.g., complex statistical charts, advanced settings) 3) Distracting elements that hinder learning focus (e.g., excessive animations, irrelevant games). Deduct 3 points for each redundancy found, and directly deduct 10 points if core learning functions are compromised by unnecessary features.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code demonstrate good engineering quality and maintainability?",
+      "description": "Review modular design separating data management, UI components, and testing logic. Check for proper code organization, reasonable variable naming, and scalability for adding new vocabulary sets. Deduct 5 points if global state pollution is found or no clear separation of concerns; deduct 5 points if code duplication rate exceeds 30%; deduct 3 points if the codebase is not easily extensible for additional features. Full score requires clean, well-structured code.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet child-friendly and educational standards?",
+      "description": "Evaluate whether the visual design is appropriate for elementary students: 1) Bright, cheerful color scheme without being overwhelming 2) Large, easily readable fonts (minimum 16px for children) 3) Clear visual hierarchy with intuitive navigation 4) Adequate spacing between interactive elements (minimum 44px touch targets). Deduct 3 points for each cluttered interface element, 5 points for poor color contrast or readability issues, and 5 points for confusing navigation that children cannot easily understand.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are interactions smooth, responsive, and provide immediate educational feedback?",
+      "description": "Judge whether the interactive experience meets educational software standards: 1) Immediate feedback on answer correctness (≤200ms response time) 2) Smooth transitions between questions without jarring effects 3) Clear visual indicators for correct/incorrect answers 4) Encouraging animations and sounds appropriate for children. Deduct 5 points for delayed feedback that disrupts learning flow, 3 points for missing visual confirmation of user actions, and 5 points for interactions that are difficult for children to understand or execute.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}