@getollie/cli 0.0.5 → 0.2.0

package/library/web_applications-education_learning/vue3-sql-to-er-diagram-converter.json

@@ -1,68 +0,0 @@
-{
-  "index": 1052,
-  "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. Implement a website that converts SQL to ER diagrams using Vue 3.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "SQL Parsing and Schema Extraction",
-      "description": "Evaluate whether the code correctly parses various SQL schemas (CREATE TABLE statements) including constraints, foreign keys, and data types. Look for robust parsing that handles edge cases like quoted identifiers, comments, and multi-line SQL. Check if the parser can detect primary keys, foreign keys, nullable fields, default values, and complex constraints.0 points if no parsing logic is implemented, 5 points for basic CREATE TABLE parsing only, 10 points for complete parsing including constraints, relationships, and handling edge cases.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "ER Diagram Generation Logic",
-      "description": "Verify if the code correctly transforms the parsed SQL schema into proper entity-relationship model components. Check if entities, attributes, relationships (one-to-one, one-to-many, many-to-many) are properly identified. Assess whether cardinality and participation constraints are correctly inferred from foreign key definitions.Deduct 3 points if relationships are incorrectly identified, 3 points if attribute types are ignored, 2 points if cardinality is wrong. Full score for accurate transformation.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Vue 3 Implementation Quality",
-      "description": "Evaluate if the code properly utilizes Vue 3 features such as Composition API, reactive state management, and component structure. Check for proper separation of concerns, reusable components, and Vue 3 best practices. Assess if the application uses ref/reactive appropriately and implements proper component lifecycle management.3 points for proper Vue 3 setup, 3 points for effective use of Composition API, 2 points for reactive state management, 2 points for well-structured components.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Diagram Visualization Technique",
-      "description": "Assess the visual representation technique (SVG/Canvas/WebGL) and rendering approach. Evaluate if entities, relationships, and attributes are visually distinguishable. Check if the diagram uses proper visual grammar (shape, color, connection styles) for ER notation standards (Chen/Crow's Foot/IE Notation/UML).Deduct 5 points if visualization is static/non-interactive, 3 points if standard ER notation principles are violated, 2 points if text/elements overlap. Full score for clean, standard-compliant visualization.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Code Robustness",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed SQL input, large schemas, circular references) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases.0 points if no exception handling exists, 5 points if basic input validation is present, 10 points if comprehensive error handling with useful error messages is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Innovative Features",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time SQL validation 2. Export to multiple formats (PNG, PDF, JSON) 3. Interactive editing of the generated diagram 4. Schema optimization suggestions 5. Collaborative sharing).Add 2 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Feature Redundancy and Performance Impact",
-      "description": "Strictly check three types of redundancy: 1. Redundant parsing implementations 2. Function modules unrelated to SQL-to-ER conversion 3. Fancy effects that affect performance (e.g., unnecessary animations, over-complex rendering).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": "Engineering Quality",
-      "description": "Review modular design (such as separating parsing logic, diagram generation, and UI components), unit test coverage, and build process automation. Check for proper error handling, code documentation, and maintenance considerations.Deduct 5 points if global state pollution is found or design patterns are not used; deduct 3 points if the code duplication rate is too high; deduct 2 points if the build process is not automated.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Interface Design Quality",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color scheme appropriate for a technical tool 2) Proper layout with clear input/output sections 3) Professional typography with proper hierarchy for SQL code and diagram elements.Deduct 3 points for each usability issue, 4 points for poor contrast/readability, 3 points for inconsistent visual styling across components.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Interaction and User Experience",
-      "description": "Judge whether the interaction flow meets users' expectations: 1) Clear input method for SQL code 2) Responsive diagram generation 3) Intuitive diagram manipulation (pan/zoom/select) 4) Proper loading states and transitions when processing large schemas.Deduct 3 points for each missing interaction capability, 2 points for laggy/unresponsive UI, 2 points for confusing workflow, 3 points for lack of visual feedback during operations.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Education/Learning",
-  "difficulty": "easy"
-}

package/library/web_applications-education_learning/vue3-vant-pdf-preview-functionality.json

@@ -1,68 +0,0 @@
-{
-  "index": 409,
-  "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. Implement PDF file preview functionality in a Vue 3 and Vant project.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the PDF preview core functionality fully implemented?",
-      "description": "Evaluate whether the implementation uses appropriate PDF rendering libraries (like PDF.js) with proper integration into Vue 3. Check if the PDF document loads correctly, pages render with proper quality, and zoom controls work. Score 0 if the core rendering is not implemented, 5 if only basic preview is available without navigation controls, and 10 if full PDF viewing capabilities are implemented including page navigation, zooming, and rotation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is Vue 3 integration correctly implemented?",
-      "description": "Verify that the PDF viewer properly utilizes Vue 3's Composition API, reactive state management, and lifecycle hooks. Check for proper component structure, ref/reactive usage, and setup() function implementation. Deduct 5 points if the implementation uses outdated patterns from Vue 2, 3 points if reactivity isn't properly utilized for PDF state management, and 2 points if proper error boundaries are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is Vant UI properly integrated with the PDF viewer?",
-      "description": "Assess whether Vant UI components are correctly used for the PDF viewer interface (e.g., buttons, loaders, icons, dialogs). Check if the implementation follows Vant design principles and responsive behaviors on mobile devices. Deduct 5 points if custom components are used where appropriate Vant components exist, 3 points if Vant theming isn't consistently applied, and 3 points if mobile adaptations are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are PDF loading states and error handling properly implemented?",
-      "description": "Check if the implementation handles different loading states (loading, success, error) with appropriate UI feedback using Vant components like Toast, Dialog, or Loading. Verify that network errors, invalid PDFs, and other edge cases are gracefully handled with user-friendly messages. Deduct 4 points for missing loading indicators, 4 points for inadequate error handling, and 2 points for missing retry mechanisms. 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 (large PDF files, slow networks, browser compatibility issues, 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 search and highlighting 2. PDF annotation capabilities 3. Thumbnail navigation panel 4. Night mode for reading). Add 2.5 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 PDF rendering engines used simultaneously) 2. Function modules unrelated to PDF preview (e.g., built-in document editor) 3. Unnecessary animations or effects that affect performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separation of PDF rendering logic from UI components), configuration options, memory management, and resource disposal. Deduct 3 points if global state pollution is found; deduct 3 points if the PDF viewer doesn't properly clean up resources when unmounted; deduct 4 points if configuration options aren't abstracted properly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the PDF viewer UI follows modern mobile design principles: 1) Consistent with Vant design language 2) Proper layout spacing for touch interactions (controls minimum 44px height) 3) Professional typography for PDF content display. Deduct 3 points for cluttered controls, 4 points for inconsistent design with the rest of the Vant application, and 3 points for poor readability of PDF content. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the PDF interactions conform to mobile touch behavior: 1) Smooth pinch-to-zoom 2) Responsive page navigation without jank 3) Clear loading progress indicators and transitions. Deduct 3 points for laggy page rendering, 3 points for unresponsive zoom controls, and 4 points for jarring page transitions or rendering artifacts. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Education/Learning",
-  "difficulty": "medium"
-}

package/library/web_applications-education_learning/vue3-vite-render-docx-webpage.json

@@ -1,68 +0,0 @@
-{
-  "index": 368,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure any code you generate is executable for demonstration purposes. Vue3 + Vite rendering docx to a webpage",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the docx rendering implementation complete?",
-      "description": "Review whether the code accurately implements docx rendering functionality using Vue3 and Vite. Check if it handles all essential document elements (paragraphs, tables, lists, images, styles, formatting). Score 0 if the core rendering is not implemented, 5 if only basic text rendering works, and 10 if the implementation handles complex document features including styles and formatting.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Vue3 component architecture well-designed?",
-      "description": "Evaluate the component hierarchy design for docx rendering. Check for proper use of Vue3 features (Composition API, setup script, reactive state management). Components should be modular, reusable, and follow single-responsibility principle. Deduct 3 points for monolithic components, 3 points for prop drilling beyond 3 levels, and 3 points for not utilizing Vue3's reactivity system effectively. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the Vite configuration properly optimized for the docx rendering?",
-      "description": "Check whether the Vite configuration is optimized for docx processing (proper plugins, asset handling, build optimization). Verify that dependencies for docx parsing are correctly integrated. Deduct 3 points if WASM/worker threads aren't used for heavy parsing, 3 points for missing code splitting, and 3 points if build optimizations aren't tailored for document processing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the docx parsing and rendering pipeline efficient?",
-      "description": "Assess the efficiency of the parsing and rendering pipeline. Check if it uses streaming parsing for large documents, implements virtualization for long documents, and optimizes render cycles. Deduct 5 points if loading 5MB+ documents causes UI freezing, 3 points if rendering is not incremental/lazy, and 5 points if memory usage grows continuously with document size. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed docx files, network interruption during file loading, memory constraints). Code with strong robustness should gracefully handle these edge cases and provide user-friendly error messages. Award 10 points for comprehensive error handling, 5 points for basic error handling, and 0 points if exceptions crash the application.",
-      "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 collaborative editing 2. Automatic document outline generation 3. Search/indexing of document content 4. Print-to-PDF with preservation of formatting). 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 parsing/rendering logic (e.g., multiple docx parsers being used) 2. Function modules unrelated to document rendering (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., excessive animations during document loading). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating parsing/rendering/UI layers), test coverage for parsing edge cases, 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 rendered document follows modern design principles: 1) Faithful reproduction of original docx styling 2) Proper layout spacing and margins 3) Professional font rendering with proper fallbacks. Deduct 3 points for inconsistent spacing between elements, 5 points for font rendering issues (jagged fonts, incorrect line height), and 5 points for layout that breaks 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) Document loading progress indicators 2) Smooth scrolling through long documents 3) Responsive UI during document processing. Deduct 5 points if loading lacks progress indication, 3 points for scroll jank or stuttering, and 5 points for UI elements that shift during document rendering. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Education/Learning",
-  "difficulty": "medium"
-}

package/library/web_applications-education_learning/web-based-text-editor.json

@@ -1,68 +0,0 @@
-{
-  "index": 1287,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code in your demonstration. Write an HTTP website that allows users to edit and save text. Using the most simple and straightforward language, tell me how to do this.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is a complete HTTP server properly implemented?",
-      "description": "Evaluate whether the code implements a proper HTTP server using appropriate frameworks/libraries (e.g., Express.js, Flask, etc.). Check if it correctly handles HTTP requests (GET, POST) for serving the editor page and saving text. Deduct 5 points if the server doesn't implement proper routing, 5 points if error handling is missing, and 5 points if it lacks appropriate HTTP status codes. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the text editor UI functionality fully implemented?",
-      "description": "Review whether the code implements a functional text editor interface with essential features like text input, cursor positioning, and basic formatting. Score 0 if there's no editor implementation, 5 if only a basic textarea is provided without any enhancement, and 10 if the editor includes proper styling, clear visual feedback, and intuitive controls for text editing. Check if the editor component is appropriately integrated with the page layout.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the text saving mechanism properly implemented?",
-      "description": "Assess whether the code includes a proper mechanism to save edited text (client-side AJAX calls, form submission, etc.) and appropriate server-side handlers to process and store the data. Check for data persistence methods (file system, database). Deduct 5 points if saving is client-side only without server persistence, 5 points if there's no feedback after saving, and 3 points if there's no validation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a text loading/retrieval mechanism to edit previously saved content?",
-      "description": "Evaluate if the code implements functionality to retrieve and load previously saved text into the editor. Check for proper handling of file/data fetching and display in the editor. Deduct 5 points if there's no way to list or select saved files, 5 points if loading doesn't maintain formatting or content integrity, and 3 points if error handling for missing files is absent. 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 empty submissions, excessively large text inputs, concurrent edits, server errors, 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. Auto-save functionality 2. Markdown support 3. Syntax highlighting 4. Version history/diff viewing). 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 saving mechanisms coexisting) 2. Function modules unrelated to text editing (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., complex animations that slow down typing). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating editor logic/view/data layers), error handling, and code organization. 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 clear separation between front-end and back-end concerns. 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) Save operation feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual feedback for saving status. Deduct 5 points for each operation without feedback, 3 points for lag during typing or saving, and 5 points for confusing UI state indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Web Applications-Education/Learning",
-  "difficulty": "easy"
-}

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

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

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

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

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