@getollie/cli 0.0.1

package/library/web_applications-education_learning/web-based-vocabulary-learning-program-with-import.json

@@ -0,0 +1,68 @@
+{
+  "index": 1027,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure that the generated code is executable for demonstration. Help me write a web-based vocabulary learning program that allows importing words from external sources, with a beautiful and eye-catching interface.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the word importing mechanism fully implemented?",
+      "description": "Review whether the code properly implements mechanisms for importing vocabulary from multiple external sources (e.g., file upload, API integration, copy-paste). Check if it handles different formats (CSV, TXT, JSON) and provides validation for imported data. Score 0 if importing is not implemented, 5 if only basic single-format importing exists, and 10 if comprehensive multi-source importing with validation is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the vocabulary storage and management system well-designed?",
+      "description": "Evaluate the data structure design for vocabulary storage. Check if it includes proper organization (categories, tags, difficulty levels), search functionality, sorting options, and persistent storage (localStorage, IndexedDB). Deduct 3 points if there's no search function, 3 points if persistent storage is missing, and 4 points if the data structure doesn't support word categorization. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are effective learning methods and review algorithms implemented?",
+      "description": "Check if the application implements spaced repetition algorithms (like Leitner system or SuperMemo), progress tracking, and adaptive learning paths. Assess if the review schedules adjust based on user performance. Deduct 5 points if no spaced repetition is implemented, 3 points if progress tracking is missing, and 2 points if there's no adaptivity in the learning sequence. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the user interaction for vocabulary learning engaging?",
+      "description": "Evaluate whether the code includes multiple learning modes (e.g., flashcards, quizzes, matching games) and provides meaningful feedback for learners. Check if different memory reinforcement techniques are used and if there's variety in the practice methods. Score 0 if only basic word display exists, 5 if there's one interactive mode with feedback, and 10 if multiple engaging learning methods are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid imports, browser storage limitations, network issues during API calls, 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 mnemonics for vocabulary 2. Audio pronunciation integration 3. Gamification elements with rewards/streaks 4. Social sharing of progress). 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 overlapping storage mechanisms) 2. Function modules unrelated to vocabulary learning 3. Fancy effects that affect loading performance and distract from learning. 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/controller layers), component reusability, and code maintainability. 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 error handling or input validation. 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) Typography hierarchy (clear distinction between headings and content). Deduct 3 points for each cluttered section, 5 points for inconsistent design patterns, and 5 points for poor responsiveness on different screen sizes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual feedback for learning progress. Deduct 5 points for each operation without feedback, 3 points for jarring transitions between learning activities, and 5 points for confusing navigation patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "medium"
+}

package/library/web_applications-education_learning/web-realtime-bus-inquiry-gaode-chelaile.json

@@ -0,0 +1,68 @@
+{
+  "index": 1406,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure that the generated code is executable for demonstration. I want to create a web-based real-time bus inquiry function, with routes, stops, and real-time data obtained from Gaode Maps or Chelaile. The frontend will be implemented using HTML+CSS+JS, and the backend will use Python. Please organize the complete code for all required pages and send them to me. If there's anything I need to replace, please let me know.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the web-based real-time bus inquiry system's core functionality implemented?",
+      "description": "Check if the code implements the core bus inquiry functionality including route search, stop lookup, and real-time arrival information. Verify that the frontend handles user queries and the backend properly integrates with Gaode Maps or Chelaile APIs. Score 0 if core inquiry function is missing, 5 if only basic route display is implemented, and 10 if comprehensive real-time tracking is fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the API integration with Gaode Maps or Chelaile properly implemented?",
+      "description": "Evaluate how the backend code handles API authentication, request rate limiting, error handling, and data parsing from the third-party services. Check for proper API key management (not hardcoded in frontend). Deduct 3 points if API keys are exposed, 3 points if error handling is inadequate, and 4 points if the integration lacks proper documentation or is incomplete. Full score requires proper API versioning support and fallback mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the real-time data update mechanism efficient?",
+      "description": "Assess whether the system implements efficient polling, WebSockets, or Server-Sent Events for real-time updates. Check for update frequency balance (not too frequent to overload APIs, not too slow to be outdated). Deduct 5 points if updates are manual-only, 3 points if the mechanism creates unnecessary API calls, and 2 points if there's no visual indication of data freshness. Full score requires intelligent update scheduling based on bus frequency and proximity.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the location-based functionality properly implemented?",
+      "description": "Check if the system uses geolocation to show nearby stops, calculates accurate walking distances, and provides relevant route suggestions. Verify permissions handling and fallbacks when location access is denied. Deduct 4 points if location accuracy is poor, 3 points if there's no permission handling, and 3 points if the system doesn't provide alternative manual location input methods. Full score requires smooth integration of maps with bus routes visualization.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as API failures, network interruptions, invalid user inputs, 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. Predictive arrival times using historical data 2. Crowdedness indicators 3. Alternative route suggestions during delays). 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 instances for the same purpose) 2. Function modules unrelated to bus inquiry (e.g., unnecessary weather widgets) 3. Fancy effects that affect performance (e.g., excessive animations that slow down critical information 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 API services/UI components/state management), 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 standards: 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 mobile-responsive?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics and mobile usage patterns: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Mobile-friendly touch targets (≥ 44px). Deduct 5 points for non-responsive design, 3 points for laggy map interactions, and 5 points for hard-to-tap bus route selections on mobile. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "hard"
+}

package/library/web_applications-education_learning/web-version-roll-call-system-css-javascript.json

@@ -0,0 +1,68 @@
+{
+  "index": 417,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable and demonstrable. Create a roll call system, web version, using CSS and JavaScript.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the roll call system's core functionality fully implemented?",
+      "description": "Review whether the code implements the essential features of a roll call system: adding/removing names, marking attendance (present/absent/late), and saving attendance records. Score 0 if these core functions are missing, 5 if only basic name listing exists, and 10 if comprehensive attendance tracking with timestamps and status indicators is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the system provide data persistence capabilities?",
+      "description": "Evaluate if the system can save attendance data (using localStorage, sessionStorage, IndexedDB, or simulated server calls). Check if the implementation includes data export functionality (CSV/JSON/PDF formats) and retrieval of historical records. Deduct 5 points if there's no data storage, 3 points if storage exists but without export options. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the user authentication and role management implemented?",
+      "description": "Assess whether the system distinguishes between different user roles (administrator, teacher, student) with appropriate permissions. Check for login functionality, session management, and role-based access controls. Deduct 5 points if no authentication exists, 3 points if roles are defined but permissions aren't properly restricted. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the system include reporting and analytics features?",
+      "description": "Check if the system generates attendance statistics (per student, per class/group, or over time), visual representations of data (charts/graphs), and summary reports. Deduct 5 points if no analytics exist, 3 points if basic statistics are shown without visualization. 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 duplicate names, invalid inputs, browser refresh, network issues) 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. QR code check-in option 2. Geolocation validation 3. Automated absence notifications 4. Voice command support). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to delete the same record) 2. Function modules unrelated to roll call (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., unnecessary animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating data/view/controller layers), code reusability, and responsiveness for different devices. Deduct 5 points if global variables are overused; deduct 5 points if the code has high duplication rate (over 30%); deduct 5 points if the system doesn't work on both desktop and mobile devices. 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 interactions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}

package/library/web_applications-education_learning/webpage-api-docs-function-navigation.json

@@ -0,0 +1,68 @@
+{
+  "index": 718,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Note that the code you generate should be executable when possible.\n{\n  \"data\": [\n    {\n      \"arg_names\": {\n        \"data\": {\n          \"type\": \"dict\"\n        }\n      },\n      \"doc\": \"Economic Operation\\n\\n        Args:\\n            data (dict): data in JSON format\\n\\n        Returns:\\n            Tuple[bool,AnyStr,Dict]: success status, message, economic operation result\\n        \",\n      \"name\": \"economic_operation\"\n    },\n    {\n      \"arg_names\": {\n        \"y_pred\": {\n          \"type\": \"list\"\n        },\n        \"y_true\": {\n          \"type\": \"list\"\n        }\n      },\n      \"doc\": \" Evaluation\\n\\n        Args:\\n            y_pred (list): predicted data\\n            y_true (list): actual data\\n\\n        Returns:\\n            Tuple[bool,str,dict]: success status, message, evaluation result{\\n                \\\"MSE\\\": Mean Square Error,\\n                \\\"RMSE\\\": Root Mean Square Error,\\n                \\\"MAE\\\": Mean Absolute Error,\\n                \\\"R2\\\": R2,\\n                \\\"MEDAE\\\": Median Error\\n            }\\n        \",\n      \"name\": \"evaluate\"\n    },\n    {\n      \"arg_names\": {\n        \"data\": {\n          \"type\": \"dict\"\n        }\n      },\n      \"doc\": \"Get Weather\\n\\n        Args:\\n            data (dict): parameters needed for the weather API\\n\\n        Returns:\\n            Tuple[bool,AnyStr,Dict]: success status, message, weather result\\n        \",\n      \"name\": \"get_weather\"\n    },\n    {\n      \"arg_names\": {\n        \"y_pred\": {\n          \"type\": \"list\"\n        },\n        \"y_true\": {\n          \"type\": \"list\"\n        }\n      },\n      \"doc\": \" Mean Absolute Error\\n\\n        Args:\\n            y_pred (list): predicted data\\n            y_true (list): actual data\\n\\n        Returns:\\n            Tuple[bool,str,float]: success status, message, mean absolute error\\n        \",\n      \"name\": \"mae\"\n    },\n    {\n      \"arg_names\": {\n        \"y_pred\": {\n          \"type\": \"list\"\n        },\n        \"y_true\": {\n          \"type\": \"list\"\n        }\n      },\n      \"doc\": \" Median Error\\n\\n        Args:\\n            y_pred (list[float]): predicted data\\n            y_true (list[float]): actual data\\n\\n        Returns:\\n            Tuple[bool,str,float]: success status, message, median error\\n        \",\n      \"name\": \"medae\"\n    },\n    {\n      \"arg_names\": {\n\n      },\n      \"doc\": \"Get Model Name List\\n\\n        Returns:\\n            Tuple[bool,AnyStr,Dict]: success status, message, model name list\\n        \",\n      \"name\": \"model_names\"\n    },\n    {\n      \"arg_names\": {\n        \"y_pred\": {\n          \"type\": \"list\"\n        },\n        \"y_true\": {\n          \"type\": \"list\"\n        }\n      },\n      \"doc\": \" Mean Square Error\\n\\n        Args:\\n            y_pred (list): predicted data\\n            y_true (list): actual data\\n\\n        Returns:\\n            Tuple[bool,str,float]: success status, message, mean square error\\n        \",\n      \"name\": \"mse\"\n    },\n    {\n      \"arg_names\": {\n        \"data\": {\n          \"type\": \"dict\"\n        },\n        \"model_name\": {\n          \"type\": \"str\"\n        },\n        \"type\": {\n          \"type\": \"str\"\n        }\n      },\n      \"doc\": \" Prediction\\n\\n        Args:\\n            data (dict): data in JSON format\\n            model_name (str): model name\\n            type (str): prediction type\\n\\n        Returns:\\n            Tuple[bool,AnyStr,List]: success status, message, prediction result\\n        \",\n      \"name\": \"predict_model\"\n    },\n    {\n      \"arg_names\": {\n        \"y_pred\": {\n          \"type\": \"list\"\n        },\n        \"y_true\": {\n          \"type\": \"list\"\n        }\n      },\n      \"doc\": \" R2\\n\\n        Args:\\n            y_pred (list): predicted data\\n            y_true (list): actual data\\n\\n        Returns:\\n            Tuple[bool,str,float]: success status, message, R2\\n        \",\n      \"name\": \"r2\"\n    },\n    {\n      \"arg_names\": {\n        \"model_name\": {\n          \"type\": \"str\"\n        }\n      },\n      \"doc\": \"Remove Model\\n\\n        Args:\\n            model_name (str): model name\\n\\n        Returns:\\n            Tuple[bool,AnyStr,None]: success status, message, None\\n        \",\n      \"name\": \"remove_model\"\n    },\n    {\n      \"arg_names\": {\n        \"y_pred\": {\n          \"type\": \"list\"\n        },\n        \"y_true\": {\n          \"type\": \"list\"\n        }\n      },\n      \"doc\": \" Root Mean Square Error\\n\\n        Args:\\n            y_pred (list): predicted data\\n            y_true (list): actual data\\n\\n        Returns:\\n            Tuple[bool,str,float]: success status, message, root mean square error\\n        \",\n      \"name\": \"rmse\"\n    },\n    {\n      \"arg_names\": {\n        \"data\": {\n          \"type\": \"dict\"\n        },\n        \"model_name\": {\n          \"type\": \"str\"\n        },\n        \"type\": {\n          \"default\": \"wind\",\n          \"type\": \"str\"\n        }\n      },\n      \"doc\": \" Train Model\\n\\n        Args:\\n            data (dict): data in JSON format\\n            model_name (str): model name\\n            type (str): training type\\n        Returns:\\n            Tuple[bool,AnyStr,None]: success status, message, None\\n        \",\n      \"name\": \"train_model\"\n    }\n  ],\n  \"is_success\": true,\n  \"msg\": \"success\"\n}\nHTML requests to an API address will retrieve this information. I need to dynamically convert this information into HTML on the webpage. On the left side, there will be a function navigation menu, and on the right side, an introduction to the functions.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the API data parsing and dynamic rendering fully implemented?",
+      "description": "Review whether the code accurately parses the JSON API response structure and dynamically generates HTML elements for function names, parameters, documentation, and return types. Check if all function metadata (arg_names, doc, name) is correctly extracted and displayed. Score 0 if basic parsing is missing, 5 if only partial data is rendered, and 10 if all API function information is completely and accurately converted to HTML.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the left navigation menu dynamically generated and interactive?",
+      "description": "Check whether the left-side navigation menu is dynamically populated from the API data with proper categorization (e.g., grouping evaluation functions like mse, rmse, mae together). Verify click handlers, active state management, and smooth scrolling to corresponding sections. Deduct 5 points if navigation lacks categorization, 3 points if active states are not properly managed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the right-side function documentation display comprehensive and well-structured?",
+      "description": "Evaluate whether the right-side content area displays complete function information including formatted documentation, parameter types with syntax highlighting, return value specifications, and usage examples. Check if the content updates dynamically when navigation items are selected. Deduct 5 points if parameter type formatting is missing, 3 points if documentation parsing is incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper error handling and API request management?",
+      "description": "Check whether the code includes comprehensive error handling for API requests, JSON parsing failures, network timeouts, and malformed data structures. Verify loading states, retry mechanisms, and graceful degradation when API is unavailable. Deduct 5 points if no loading indicators are present, 3 points if error states are not handled gracefully. Give 10 points if fully robust.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as empty API responses, malformed JSON, missing function properties, 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. Search functionality across functions 2. Code example generation for each function 3. Interactive parameter input forms 4. Function usage statistics 5. Export documentation as PDF). 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 JSON parsing logics coexisting) 2. Function modules unrelated to API documentation display (e.g., built-in games or unnecessary widgets) 3. Fancy effects that affect performance (e.g., excessive animations or heavy graphics). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core 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 handling/rendering/navigation logic), code organization, and maintainability. Deduct 5 points if global state pollution is found or no separation of concerns; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no proper async/await patterns are used for API calls. 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) Proper left-right layout with clear visual hierarchy 2) Consistent spacing and typography (navigation items properly spaced, readable font sizes ≥ 14px) 3) Professional color scheme distinguishing navigation, content areas, and code syntax. Deduct 3 points for each cramped visual element, 5 points for poor color contrast, and 5 points for inconsistent layout spacing. 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) Navigation click response ≤ 100ms 2) Smooth content transitions when switching between functions 3) Clear visual feedback for loading states and hover effects 4) Proper scroll behavior and focus management. Deduct 5 points for each laggy interaction, 3 points for missing hover states, and 5 points for poor content transition effects. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "medium"
+}

package/library/web_applications-education_learning/webpage-code-preview-editor.json

@@ -0,0 +1,68 @@
+{
+  "index": 703,
+  "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 display. Help me create HTML code for a webpage that can preview the generated code, with an interface divided into two parts: the left side for pasting, deleting, and modifying code, and the right side for real-time preview of the webpage generated by this code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Check if the HTML code correctly implements a two-panel layout with clear separation between the code editing area (left) and preview area (right). The layout should be responsive and maintain proper proportions across different screen sizes. Score 0 if the dual-panel structure is missing, 5 if implemented but with layout issues, 10 if perfectly implemented with responsive design considerations.",
+      "description": "Check if the HTML code correctly implements a two-panel layout with clear separation between the code editing area (left) and preview area (right). The layout should be responsive and maintain proper proportions across different screen sizes. Score 0 if the dual-panel structure is missing, 5 if implemented but with layout issues, 10 if perfectly implemented with responsive design considerations.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Evaluate if the code editor panel provides essential editing features: text input area with proper styling (syntax highlighting preferred), clear buttons for operations (paste/delete/modify), and appropriate keyboard shortcuts. The editor should handle various HTML inputs correctly, including special characters. Deduct 5 points if syntax highlighting is missing, 3 points if keyboard shortcuts aren't implemented, and 2 points if the editor doesn't preserve whitespace formatting. Full score is 10 points.",
+      "description": "Evaluate if the code editor panel provides essential editing features: text input area with proper styling (syntax highlighting preferred), clear buttons for operations (paste/delete/modify), and appropriate keyboard shortcuts. The editor should handle various HTML inputs correctly, including special characters. Deduct 5 points if syntax highlighting is missing, 3 points if keyboard shortcuts aren't implemented, and 2 points if the editor doesn't preserve whitespace formatting. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Verify that changes in the editor are reflected in real-time in the preview panel without requiring manual refresh. Check if the preview handles updating without flickering and maintains scroll position when appropriate. Implementation should use efficient event listening (e.g., input events with debouncing). Deduct 5 points if updates require manual action, 3 points if there's significant delay (>300ms), and 2 points if the preview flickers during updates. Full score is 10 points.",
+      "description": "Verify that changes in the editor are reflected in real-time in the preview panel without requiring manual refresh. Check if the preview handles updating without flickering and maintains scroll position when appropriate. Implementation should use efficient event listening (e.g., input events with debouncing). Deduct 5 points if updates require manual action, 3 points if there's significant delay (>300ms), and 2 points if the preview flickers during updates. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Assess whether the system gracefully handles invalid HTML input without breaking the preview or editor functionality. It should provide user feedback about errors (highlighting or error messages) and attempt to render what it can despite errors. Deduct 5 points if invalid code causes the preview to break completely, 3 points if no error feedback is provided, and 2 points if the system doesn't attempt partial rendering of valid portions. Full score is 10 points.",
+      "description": "Assess whether the system gracefully handles invalid HTML input without breaking the preview or editor functionality. It should provide user feedback about errors (highlighting or error messages) and attempt to render what it can despite errors. Deduct 5 points if invalid code causes the preview to break completely, 3 points if no error feedback is provided, and 2 points if the system doesn't attempt partial rendering of valid portions. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Evaluate whether the code can handle common abnormal situations (such as extremely large code inputs, script injection attempts, iframe security issues) 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.",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as extremely large code inputs, script injection attempts, iframe security issues) 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": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Code formatting/beautifying options 2. Multiple theme support for the editor 3. Ability to save/load snippets locally). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Code formatting/beautifying options 2. Multiple theme support for the editor 3. Ability to save/load snippets locally). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to accomplish the same editing task) 2. Function modules unrelated to code editing and previewing (e.g., a built-in chat system) 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.",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to accomplish the same editing task) 2. Function modules unrelated to code editing and previewing (e.g., a built-in chat system) 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": "Review modular design (such as separating UI/logic/event handling), code organization, and maintainability. Deduct 5 points if global namespace pollution is found or if proper event delegation isn't used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between structure, presentation, and behavior (HTML/CSS/JS). The full score is 10 points.",
+      "description": "Review modular design (such as separating UI/logic/event handling), code organization, and maintainability. Deduct 5 points if global namespace pollution is found or if proper event delegation isn't used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between structure, presentation, and behavior (HTML/CSS/JS). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "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 (monospace font for editor, appropriate size contrast between panels). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for poor visual distinction between panels. The full score is 10 points.",
+      "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 (monospace font for editor, appropriate size contrast between panels). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for poor visual distinction between panels. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Judge whether the dynamic effects conform to human perception characteristics: 1) Editor responsiveness ≤ 50ms 2) Preview update speed ≤ 300ms 3) Clear visual indication during processing/updating. Deduct 5 points for noticeable lag when typing in the editor, 3 points for missing loading indicators during preview updates, and 5 points for interaction elements without hover/focus states. The full score is 10 points.",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Editor responsiveness ≤ 50ms 2) Preview update speed ≤ 300ms 3) Clear visual indication during processing/updating. Deduct 5 points for noticeable lag when typing in the editor, 3 points for missing loading indicators during preview updates, and 5 points for interaction elements without hover/focus states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}

package/library/web_applications-education_learning/webpage-display-realtime-data-specific-stocks-trading-limit.json

@@ -0,0 +1,68 @@
+{
+  "index": 240,
+  "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. Please help me write a code program for a webpage that can display real-time data for specific stocks, such as stocks that hit the second trading limit and then broke through that limit in today's A-share market.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the real-time stock data acquisition and handling system properly implemented?",
+      "description": "Evaluate whether the code includes proper API connections to retrieve real-time A-share market data (using WebSocket or polling), with appropriate data handling for stock limit calculations. Check if the system correctly identifies stocks hitting the second trading limit and subsequently breaking through. Score 0 if no real-time data connection is implemented, 5 if basic polling is used without WebSocket for true real-time updates, and 10 if a complete real-time data pipeline with proper error handling is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the stock limit detection algorithm accurately implemented?",
+      "description": "Assess whether the code correctly implements the logic to detect A-share market trading limits (+10%/-10% or +5%/-5% depending on stock type) and specifically identifies second trading limits and breakthrough events. The algorithm should account for different stock types (main board, ChiNext, STAR Market) which have different limit rules. Deduct 5 points if the algorithm doesn't differentiate between stock types, 3 points if it can't detect second limit breakthroughs correctly, and give 0 points if the core limit detection is flawed.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the data visualization component effectively built?",
+      "description": "Review the visualization of stock data using appropriate charts (candlestick, line, volume) with clear indication of limit points. Charts should include proper labeling, tooltips, and responsive design. Score 10 if visualization includes advanced features like zooming, highlighting breakthrough moments, and interactive elements; 5 if basic visualization is present but lacks interactivity; 0 if visualization is missing or fundamentally flawed.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the real-time alert/notification system implemented?",
+      "description": "Check if the system provides timely alerts when stocks hit second limits or break through limits. The notification system should offer visual indicators, sound alerts, and/or browser notifications. Assess whether users can customize alert settings. Deduct 3 points if notifications aren't real-time, 5 points if customization is missing, and give 0 points if no notification system exists at all.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common abnormal situations (such as API failures, data delays, network interruptions, etc.) and provides friendly error prompts or recovery mechanisms. Check if there's appropriate error handling for market close periods and pre-market/post-market sessions. Score 10 points for comprehensive error handling and recovery strategies, 5 points for basic error handling, and 0 points if exceptions are unhandled.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Historical pattern recognition for limit breakthroughs 2. Correlation analysis with market indices 3. Automatic generation of technical analysis for stocks hitting limits). 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 data fetching methods 2. Function modules unrelated to stock tracking (e.g., unnecessary news feeds) 3. Fancy effects that affect performance (e.g., excessive animations that slow down data updates). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core stock monitoring 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 service/visualization/UI components), unit test coverage, and build process automation. Check for proper state management (React context, Redux, etc.) and component reusability. 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; 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 financial dashboard standards?",
+      "description": "Evaluate whether the design follows financial dashboard best practices: 1) Professional color scheme suitable for financial data (appropriate use of red/green for up/down movements) 2) Clear data hierarchy with primary and secondary information properly distinguished 3) Proper density of information without overwhelming users. Deduct 3 points for poor information hierarchy, 5 points for non-standard financial color coding, and 5 points for overwhelming or cluttered interfaces. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive to market changes?",
+      "description": "Judge whether data updates and UI responses meet financial trading requirements: 1) Data refresh rate appropriate for A-share market movements 2) Clear visual indication of data freshness and last update time 3) Smooth transitions for price changes without disrupting user focus. Deduct 5 points if data appears to lag significantly, 3 points for jarring visual updates that make tracking difficult, and 5 points if there's no indication of data staleness during connection issues. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "hard"
+}

package/library/web_applications-education_learning/webpage-exams-score-calculation.json

@@ -0,0 +1,68 @@
+{
+  "index": 1625,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that any code you generate is executable for demonstration. Source code for automatic score calculation in webpage exams.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core score calculation algorithm correctly implemented?",
+      "description": "Review whether the algorithm accurately calculates scores based on exam inputs, handles various question types (multiple-choice, fill-in-the-blank, essay), and applies appropriate weighting. Check for edge cases like partial credit. Score 0 if the core calculation is incorrect, 5 if basic calculation works but lacks handling of complex question types, and 10 if all question types and scoring scenarios are handled accurately.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the input validation and error handling robust?",
+      "description": "Evaluate how the code validates user inputs, prevents submission of incomplete answers, and handles edge cases (blank answers, malformed inputs, etc.). Check for defensive programming techniques like form validation, input sanitization, and graceful error handling. Deduct 5 points if basic validation is missing, 3 points if error messages aren't user-friendly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the score persistence and reporting system implemented?",
+      "description": "Check whether the code includes mechanisms to store scores (localStorage, database integration, etc.), generate reports, and provide analytics. Verify if historical scores are accessible and if comparative analysis features are available. Deduct 5 points if scores aren't persistent across page reloads, 3 points if reporting functionality is limited. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the exam timing and auto-submission functionality properly implemented?",
+      "description": "Assess whether the code handles exam time limits, provides countdown timers, sends warnings when time is running low, and auto-submits when time expires. Check if the timer persists across page reloads. Deduct 5 points for no auto-submission, 3 points for timer inaccuracies, 2 points if time warnings are missing. 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 (invalid inputs, browser crashes, network issues) and provide friendly error prompts or recovery mechanisms. Test for race conditions in timing and submission functions. 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 score feedback 2. Anti-cheating mechanisms 3. Personalized performance analytics). 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 calculation methods for the same score 2. Unnecessary animations or effects that distract from the exam experience 3. Heavy libraries included but barely used. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separation of UI/scoring logic/data handling), code reusability, and presence of automated tests. Evaluate code structure, naming conventions, and comments. Deduct 5 points if global variables are overused; 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 design standards?",
+      "description": "Evaluate whether the exam UI follows modern design principles: 1) Clean layout with clear question grouping 2) Proper visual hierarchy for questions vs. answers 3) Accessible design with sufficient contrast and readable fonts. Deduct 3 points for cluttered question layout, 5 points for poor readability, and 5 points for confusing navigation between questions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the exam interaction conforms to user expectations: 1) Question navigation is intuitive 2) Answer submission provides immediate feedback 3) Score calculation and display is transparent. Deduct 5 points for laggy response when selecting answers, 3 points for confusing submission process, and 5 points for unclear scoring feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}

package/library/web_applications-education_learning/webpage-for-reading-free-novels.json

@@ -0,0 +1,68 @@
+{
+  "index": 1333,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable and functional. Help me create a webpage for reading novels, with the requirement that all resources are free.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core novel reading functionality fully implemented?",
+      "description": "Review whether the code implements essential reading features: chapter navigation, bookmarking, text display with proper formatting, and reading progress tracking. Score 0 if core reading functionality is missing, 5 if basic text display is implemented, and 10 if all essential reading features are included with smooth transitions between chapters.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the content management system properly implemented?",
+      "description": "Check whether the code includes functionality to manage novel content: importing/adding new novels, organizing content by categories/genres, search functionality, and history tracking. Deduct 5 points if search functionality is missing, 3 points if category organization is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is user experience for extended reading properly addressed?",
+      "description": "Evaluate whether the implementation includes eye-care features (dark mode, font size adjustment, line spacing, margins), reading time tracking, and mobile responsiveness. Deduct 3 points if font customization is missing, 3 points if dark mode is not implemented, and 4 points if the design isn't responsive. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is content sourcing handled legally and efficiently?",
+      "description": "Assess whether the code uses legal sources for content (public domain works, user-uploaded content with proper rights management, or APIs with proper attribution). Check if content is cached locally to reduce bandwidth usage. Deduct 5 points if no content source verification exists, 5 points if copyright notices are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruptions, missing book content, broken images, 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. Text-to-speech functionality 2. Reading statistics and analytics 3. Social sharing with highlights 4. Vocabulary builder for difficult words). 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 theme switchers) 2. Function modules unrelated to novel reading (e.g., a built-in game) 3. Fancy effects that affect loading speed and reading experience (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 UI/data/state management), code reusability, and performance optimization techniques. 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 no performance optimization for large texts is implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching suitable for extended reading (no more than 3 primary colors) 2) Proper layout spacing (consistent margins, paragraphs properly separated) 3) Professional typography (readable font choices, proper line height 1.5-1.8, optimal line length 60-80 characters). Deduct 3 points for poor spacing, 5 points for poor readability, and 5 points for cluttered 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) Page turning feels natural with appropriate animations 2) UI controls appear/disappear smoothly when needed 3) Loading indicators for content fetching. Deduct 5 points for jarring page transitions, 3 points for laggy scrolling, and 5 points for hard-to-access reading controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "medium"
+}