@getollie/cli 0.0.4 → 0.2.0

package/library/mermaid_flowcharts-logic_flowcharts/digital-twin-long-boom-assembly-bs-architecture.json

@@ -1,68 +0,0 @@
-{
-  "index": 1415,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the generated code is executable whenever possible. Based on the following content, please help me design a diagram.\n\nDevelop a digital twin system for controlling deviations in long boom assembly processes based on the Browser-Server (BS) architecture model, as shown in the figure. Adopt a front-end and back-end separation development model to improve system maintainability and development efficiency. The back-end algorithm model is developed using Python language, while the front-end builds an interactive user interface through the modern JavaScript framework React. The system uses MySQL database to process and store large amounts of data and interacts with the back-end through APIs. The Fetch API, an HTTP client library, is used to implement communication between the front-end and back-end.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the digital twin system architecture properly designed?",
-      "description": "Evaluate whether the code implements a complete BS architecture with clear front-end/back-end separation. Check if React is properly integrated on the front-end and Python on the back-end, with appropriate API interfaces between them. The architecture should include data flow diagrams showing how information moves between components.0 points if basic architecture is missing, 5 points if only basic separation exists, 10 points if complete architecture with clear component responsibilities and data flows is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the long boom assembly process modeling accurate?",
-      "description": "Review whether the code includes accurate physical models representing the long boom assembly, incorporating key parameters like dimensions, articulation points, and deviation measurements. The model should handle various assembly states and predict potential deviations.0 points if boom assembly modeling is absent, 5 points if basic modeling exists without deviation handling, 10 points if comprehensive modeling with accurate physical properties and deviation prediction is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the deviation control algorithm implemented effectively?",
-      "description": "Examine the Python backend code for algorithms that detect, analyze, and correct deviations in the assembly process. Check for mathematical models, statistical analysis, and correction recommendations.0 points if no deviation control algorithm exists, 5 points if basic detection without correction recommendations is implemented, 10 points if comprehensive algorithms with predictive capabilities and correction strategies are present.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the front-end and back-end communication properly implemented?",
-      "description": "Check if the Fetch API implementation includes proper error handling, request/response formatting, authentication, and real-time data exchange capabilities. Verify that API endpoints are RESTful or follow consistent patterns.0 points if communication is broken, 5 points if basic communication works but lacks error handling or security, 10 points if robust communication with authentication, error handling, and optimized data transfer is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as sensor data corruption, network interruption, user operation errors, etc.) and provide friendly error prompts or recovery mechanisms.0 points if no exception handling exists, 5 points if basic error handling is present, 10 points if comprehensive exception handling with recovery mechanisms is implemented.",
-      "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 3D visualization of deviations 2. Predictive maintenance alerts 3. AR overlay for assembly guidance).Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple visualization methods) 2. Function modules unrelated to digital twin objectives 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 processing/visualization/control logic layers), unit test coverage, and build process automation. Check database design for normalization and indexing.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 dashboard design follows industrial visualization standards: 1) Clear information hierarchy 2) Appropriate use of color for status indication 3) Balanced data density without overwhelming users 4) Responsive design for different screen sizes.Deduct 3 points for each crowded visual element, 5 points for ineffective use of color in status indication, and 5 points for non-responsive layouts. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the digital twin visualization updates smoothly: 1) Real-time data updates without visible lag 2) Smooth transitions between different views/states 3) Intuitive interaction for adjustment and control 4) Clear visual feedback for user actions.Deduct 5 points for lagging visualizations, 3 points for abrupt transitions between states, and 5 points for unintuitive interaction patterns. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Mermaid Flowcharts-Logic Flowcharts",
-  "difficulty": "medium"
-}

package/library/mermaid_flowcharts-logic_flowcharts/sample-code-retejs-vue-3-setup-script-syntax.json

@@ -1,68 +0,0 @@
-{
-  "index": 1639,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes. Provide sample code for using Rete.js in Vue 3, using the setup script syntax sugar.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is Rete.js core integration properly implemented?",
-      "description": "Review whether the code correctly integrates Rete.js with Vue 3 setup syntax, including proper engine initialization, area plugin configuration, and connection plugin setup. Check if the node editor instance is properly created and mounted to DOM elements. Score 0 if core Rete engine is not initialized, 5 if only basic editor is created without plugins, and 10 if complete integration with all essential plugins (Area, Connection, Render) is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are custom nodes and sockets correctly defined and functional?",
-      "description": "Evaluate whether custom node types are properly defined with input/output sockets, control elements, and data processing logic. Check if nodes can be added to the editor, connected properly, and execute their intended functions. Deduct 5 points if socket connections don't work, 3 points if node controls are non-functional. Full score requires at least 2-3 different node types with proper socket definitions and working connections.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is Vue 3 reactivity system properly integrated with Rete.js?",
-      "description": "Check whether Vue 3's composition API (ref, reactive, computed) is correctly used to manage Rete.js state and provide reactive updates. Evaluate if changes in Vue components properly sync with Rete editor state and vice versa. Deduct 5 points if reactivity is broken or causes memory leaks, 3 points if state synchronization is inconsistent. Full score requires seamless two-way data binding between Vue and Rete.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the data flow processing engine implemented with proper execution logic?",
-      "description": "Assess whether the node graph can execute properly with data flowing through connections, including proper input validation, data transformation, and output generation. Check if the execution order respects node dependencies and handles circular references. Deduct 5 points if execution logic is missing, 3 points if data types are not properly validated. Full score requires complete data processing pipeline with error handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid node connections, missing dependencies, component lifecycle issues, memory leaks from Rete instances, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases and provide proper cleanup on component unmount, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Custom node templates with drag-and-drop palette 2. Real-time preview of node execution results 3. Serialization/deserialization of node graphs 4. Minimap or zoom controls 5. Undo/redo functionality). 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 editor initialization logic) 2. Function modules unrelated to Rete.js demonstration (e.g., unnecessary UI components) 3. Overly complex examples that obscure the core Rete.js usage patterns. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core Rete.js demonstration is interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating node definitions, editor configuration, and Vue components), proper TypeScript usage if applicable, and Vue 3 best practices compliance. Deduct 5 points if global state pollution is found or composition API patterns are misused; deduct 5 points if code structure is poorly organized; deduct 5 points if dependencies are not properly managed. 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 for nodes and connections (no more than 3 primary colors) 2) Proper layout spacing (node editor container and controls follow consistent spacing) 3) Professional typography (readable node labels, proper font hierarchy). Deduct 3 points for each visually crowded element, 5 points for clashing color combinations, and 5 points for poor visual hierarchy. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the node editor interactions conform to user expectations: 1) Node dragging responsiveness ≤ 16ms for 60fps 2) Connection creation with smooth bezier curves and visual feedback 3) Hover states and selection feedback are immediate and clear 4) Zoom and pan operations are fluid. Deduct 5 points for each laggy interaction, 3 points for poor visual feedback during operations, and 5 points for confusing interaction patterns. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Mermaid Flowcharts-Logic Flowcharts",
-  "difficulty": "hard"
-}

package/library/mermaid_flowcharts-logic_flowcharts/vue-flow-architectural-contract-approval-diagram.json

@@ -1,68 +0,0 @@
-{
-  "index": 1069,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure that any code you provide is executable. Create a demonstration diagram of a contract approval process for an architectural design project based on vue-flow.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core contract approval process flow correctly implemented with vue-flow?",
-      "description": "Check whether the code correctly implements the architectural contract approval process using vue-flow, including proper node types (start, approval steps, decision points, end), directed edges with correct flow direction, and appropriate edge styles. Score 0 if vue-flow is not implemented at all, 5 if only basic nodes and edges are present without proper flow logic, and 10 if the complete architectural design approval process is accurately represented with appropriate node types and logical flow connections.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the approval stages for the architectural design project properly defined?",
-      "description": "Evaluate whether the demonstration includes all essential stages of an architectural design contract approval process (e.g., initial submission, preliminary review, technical evaluation, financial assessment, final approval, etc.). Deduct 2 points for each missing critical stage. Check if conditional paths and decision points are correctly implemented (e.g., reject/revise/approve branches). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the vue-flow interaction functionality properly implemented?",
-      "description": "Verify if essential vue-flow interactions are implemented, including: node dragging, connection creation/deletion, panning/zooming, node selection, and mini-map (if applicable). Test if custom interactions relevant to contract approval (like approval action buttons, status changes, document attachment) are functional. Deduct 2 points for each missing core interaction feature. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the demonstration include appropriate data models for architectural contracts?",
-      "description": "Check if the code implements proper data structures for architectural contract entities, including contract metadata (parties involved, project details, financial terms), approval history, current status tracking, and document references. Examine if state management is implemented correctly. Deduct 3 points if the data model is incomplete, 5 points if data persistence is missing, and 2 points if state updates don't trigger appropriate UI changes. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid node connections, concurrent editing conflicts, network interruptions, loading large diagrams) 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. Real-time collaboration functionality 2. Approval timeline visualization 3. Document preview integration 4. Automated notifications for stakeholders). 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 approve a contract) 2. Function modules unrelated to architectural contract approval (e.g., built-in chat that's not for approval communication) 3. Fancy effects that affect performance (e.g., excessive animations that slow down diagram 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": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating flow logic/UI components/data services), component reusability, and build process optimization. Deduct 5 points if global state pollution is found or proper Vue composition API/options API patterns are not followed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not optimized for vue-flow integration. 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 a professional architectural contract system (using color coding for approval states) 2) Proper layout spacing with clear visual hierarchy between the flow diagram and supporting UI elements 3) Professional font system appropriate for technical documentation. Deduct 3 points for each crowded visual element, 5 points for unclear node status indicators, and 5 points for poor readability of critical contract information. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Node dragging and connecting feels responsive (≤ 100ms feedback) 2) Transition animations for approval status changes are meaningful and appropriately timed (300-500ms) 3) Clear visual feedback for user actions like approvals/rejections. Deduct 5 points for laggy diagram manipulation, 3 points for confusing transition effects between approval states, and 5 points for unclear visual feedback when interacting with critical approval functions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Mermaid Flowcharts-Logic Flowcharts",
-  "difficulty": "easy"
-}

package/library/mermaid_flowcharts-mind_maps/mind-map-similar-to-xmind.json

@@ -1,68 +0,0 @@
-{
-  "index": 1051,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration purposes. Output a mind map similar to XMind, as visual representations are easier for humans to understand.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the mind map core structure fully implemented?",
-      "description": "Review whether the code accurately implements the hierarchical tree structure through HTML/JavaScript/SVG, including node creation, parent-child relationships, and dynamic branching. Check if it supports multi-level nesting (at least 5 levels deep) and proper node positioning algorithms. Score 0 if basic tree structure is missing, 5 if only 2-3 levels are supported, and 10 if full hierarchical functionality with proper algorithms is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are interactive editing features comprehensively implemented?",
-      "description": "Evaluate whether the implementation includes essential mind map operations: adding/deleting nodes, editing text content, dragging to reorganize structure, and keyboard shortcuts support. Check for real-time content saving and undo/redo functionality. Deduct 3 points if drag-and-drop is not smooth, 5 points if keyboard navigation is missing, and 2 points if text editing has no auto-save. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the visual rendering engine optimized and scalable?",
-      "description": "Check whether the rendering system uses efficient algorithms for large datasets (1000+ nodes), implements proper viewport culling, and supports smooth zoom/pan operations. Evaluate if it uses canvas/SVG optimization techniques and maintains 60fps during interactions. Deduct 5 points if performance drops with 100+ nodes, 3 points if zoom operations are laggy, and 5 points if no viewport optimization exists. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are data export and import capabilities properly implemented?",
-      "description": "Verify whether the system supports multiple export formats (JSON, XML, image formats like PNG/SVG) and can import standard mind map formats. Check if the data structure preserves all visual and structural information during export/import cycles. Deduct 4 points if only one export format is supported, 3 points if imported data loses styling information, and 3 points if export images have quality issues. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid input data, browser compatibility issues, memory leaks during long usage, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases like empty nodes, circular references, and malformed import data, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-powered topic suggestions 2. Collaborative real-time editing 3. Smart auto-layout algorithms 4. Integration with external knowledge bases 5. Advanced search and filtering). 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 layout algorithms doing the same thing) 2. Function modules unrelated to mind mapping (e.g., built-in games or unrelated widgets) 3. Fancy effects that affect performance (e.g., excessive animations or particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if 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 model/view/controller layers), code organization, and maintainability. Check for proper separation of concerns, consistent coding style, and documentation quality. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if the code structure is chaotic with poor maintainability. 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 mind map UX principles: 1) Harmonious color scheme with proper contrast for nodes 2) Consistent visual hierarchy and spacing (following 8px grid system) 3) Professional typography (readable fonts, proper sizes ≥ 12px) 4) Intuitive iconography and visual cues. Deduct 3 points for each visually crowded element, 5 points for poor color accessibility, and 5 points for inconsistent visual language. 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) Node creation/deletion with smooth transitions 2) Hover states with immediate feedback (≤ 100ms) 3) Pan and zoom operations feel natural and responsive 4) Connection lines animate smoothly during restructuring 5) Loading states are properly handled. Deduct 5 points for each operation without visual feedback, 3 points for jerky animations, and 5 points for unresponsive interactive elements. Full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Mermaid Flowcharts-Mind Maps",
-  "difficulty": "hard"
-}

package/library/mermaid_flowcharts-mind_maps/mind-mapping-mini-program.json

@@ -1,68 +0,0 @@
-{
-  "index": 1393,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code where possible. Create a practical mind mapping mini-program or executable HTML code that will allow me to easily create mind maps.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core mind mapping functionality fully implemented?",
-      "description": "Review whether the code accurately implements node creation, deletion, editing, and hierarchical relationships through HTML/JavaScript/SVG. Must include drag-and-drop node positioning, parent-child relationship management, and dynamic branch connections. Score 0 if basic node operations are missing, 5 if only static node display is implemented, and 10 if full interactive mind mapping with real-time connection updates is achieved.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the visual node connection system properly implemented?",
-      "description": "Check whether the connection lines between nodes use proper algorithms (Bezier curves or optimized paths) and dynamically update when nodes are moved. Evaluate if connection points are accurately calculated and visually appealing. Deduct 5 points if connections don't follow nodes during drag operations, 3 points if line overlapping issues exist, and 5 points if connection algorithms cause performance issues. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is comprehensive data persistence and export functionality provided?",
-      "description": "Evaluate whether the mind map data can be saved locally (localStorage/IndexedDB) and exported in standard formats (JSON/XML/PNG/SVG). Check if import functionality exists for data recovery. Deduct 5 points if only basic localStorage is used without proper data structure, 3 points if export formats are limited, and 5 points if no import/recovery mechanism exists. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is advanced mind mapping interaction design implemented?",
-      "description": "Check whether the code includes professional mind mapping features such as node styling customization (colors, shapes, fonts), zoom and pan functionality, keyboard shortcuts, and multi-selection operations. Deduct 5 points if zoom/pan is not smooth or missing, 3 points if keyboard shortcuts are not implemented, and 5 points if node customization options are limited. Give 10 points if fully implemented with professional UX patterns.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust and handles edge cases properly?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid node operations, data corruption, browser compatibility issues, and memory leaks during extensive mind map creation). Code with strong robustness should effectively handle these edge cases and provide user-friendly error messages. Give 10 points for excellent error handling, 5 points for basic exception handling, and 0 points if no error handling exists.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there innovative features that enhance user experience?",
-      "description": "Check whether the code includes advanced features that distinguish it from basic mind mapping tools (e.g., 1. Auto-layout algorithms for optimal node positioning 2. Template system with predefined mind map structures 3. Real-time collaboration features 4. AI-powered content suggestions 5. Advanced search and filtering). Add 2-3 points for each well-implemented innovative feature (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant or unnecessary features?",
-      "description": "Strictly check for three types of redundancy: 1. Duplicate functionality implementations (e.g., multiple save mechanisms that conflict) 2. Features unrelated to mind mapping core purpose (e.g., built-in games or social media integration) 3. Over-engineered animations that impact performance without adding value. Deduct 3 points for each redundancy found, and deduct 10 points if redundant code interferes with core mind mapping functionality.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code demonstrate high engineering quality standards?",
-      "description": "Review modular architecture (separation of data model, view rendering, and user interaction layers), code organization, and maintainability. Check for proper event handling, memory management, and performance optimization. Deduct 5 points for poor separation of concerns or spaghetti code structure; deduct 5 points if code duplication exceeds 25%; deduct 5 points for inefficient DOM manipulation or rendering bottlenecks. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface design meet professional visual standards?",
-      "description": "Evaluate whether the mind mapping interface follows modern design principles: 1) Clean and intuitive toolbar design with proper iconography 2) Consistent color scheme that enhances readability (background contrast ratio ≥ 4.5:1) 3) Proper spacing and typography (minimum 12px font size, adequate line spacing). Deduct 3 points for cluttered UI elements, 5 points for poor color contrast or accessibility issues, and 5 points for inconsistent visual hierarchy. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Are the interactive animations smooth and enhance usability?",
-      "description": "Judge whether dynamic effects support productive mind mapping workflow: 1) Node creation/deletion animations are smooth and provide clear feedback 2) Drag operations have appropriate visual cues and snap-to-grid behavior 3) Zoom/pan transitions are fluid without jarring jumps 4) Loading states and transitions don't interrupt user flow. Deduct 5 points for laggy animations during complex operations, 3 points for missing visual feedback on user actions, and 5 points for disorienting or excessive animations. Full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Mermaid Flowcharts-Mind Maps",
-  "difficulty": "hard"
-}

package/library/mermaid_flowcharts-mind_maps/online-editable-mind-map.json

@@ -1,68 +0,0 @@
-{
-  "index": 1177,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure that any code you generate is executable and can be demonstrated. Create an online-editable mind map.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core mind map rendering system fully implemented?",
-      "description": "Check whether the code creates a complete visual mind map structure with nodes and connections using SVG/Canvas/HTML. Verify if it includes essential features like node creation, connection drawing, and hierarchical representation. Score 0 if the mind map structure is not implemented, 5 if basic node display is implemented without proper connections, and 10 if a complete hierarchical mind map with proper visualization is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the editing functionality comprehensive?",
-      "description": "Evaluate whether users can add, edit, delete, and move nodes through intuitive interactions. Check for features like inline text editing, node dragging, context menus, and keyboard shortcuts. Deduct 3 points if inline editing is missing, 3 points if drag-and-drop functionality isn't smooth, and 4 points if keyboard shortcuts aren't implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the data structure design optimized for mind maps?",
-      "description": "Assess whether the code uses an appropriate tree-like data structure that efficiently represents hierarchical relationships and supports operations like adding child nodes, reordering siblings, and collapsing/expanding branches. Check if the data model is separate from the view layer. Deduct 5 points if the data structure doesn't properly maintain parent-child relationships, and 5 points if there's no clean separation between data and presentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are data persistence and sharing mechanisms implemented?",
-      "description": "Verify if the mind map can be saved (locally or cloud-based) and if the implementation includes export/import functionality in standard formats (like JSON, FreeMind, etc.). Check if there's a real-time collaboration feature or sharing capability. Award 3 points for local storage implementation, 3 points for export/import functionality, and 4 points for sharing or collaboration features. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid input, browser compatibility issues, large mind maps, etc.) and provide friendly error prompts or recovery mechanisms. Check for defensive programming practices like input validation and error handling. 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-layout algorithms 2. Rich node formatting options 3. Image/attachment support 4. Node filtering/searching 5. Presentation mode). Add 2 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 achieve the same editing operation) 2. Function modules unrelated to mind mapping (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating data model/view/controller layers), unit test coverage, and code organization. Check for proper event handling patterns and performance optimization for large mind maps. 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 (over 30%); deduct 2 points if there's no performance optimization for large datasets. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing and node distribution 3) Professional font system (consistent typography hierarchy, readable font sizes) 4) Intuitive visual cues for editing operations. Deduct 3 points for each crowded visual element, 3 points for a glaring color combination, and 4 points for confusing user interface elements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Node creation/editing feedback delay ≤ 100ms 2) Smooth animations for expanding/collapsing nodes (300-500ms) 3) Responsive drag-and-drop with visual feedback 4) Clear indication of selected/active nodes. Deduct 3 points for each operation without feedback, 2 points for jerky animations during interactions, and 5 points for hard-to-use editing controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Mermaid Flowcharts-Mind Maps",
-  "difficulty": "easy"
-}

package/library/mermaid_flowcharts-mind_maps/present-research-findings-mind-map-markmap.json

@@ -1,68 +0,0 @@
-{
-  "index": 1238,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Present the main research findings in a mind map format. Output using markmap code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the markmap implementation complete and functional?",
-      "description": "Evaluate whether the markmap code correctly implements the core HTML/JavaScript structure required for mind map visualization. Check if the code includes proper initialization of the markmap library, DOM element creation, and rendering logic. Score 0 if no functional markmap implementation is present, 5 if basic structure exists but has functionality issues, and 10 if the markmap renders properly with correct hierarchical structure.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the data structure for the mind map properly designed?",
-      "description": "Assess whether the mind map data structure follows a logical hierarchical format with proper parent-child relationships. Check for appropriate nesting levels, clear node relationships, and coherent organization of information. Deduct 5 points if the hierarchy is flat or poorly organized, 3 points if some relationships are illogical. Full points require a well-structured tree-like data format that clearly represents conceptual relationships.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the research findings accurately represented in the mind map?",
-      "description": "Verify that the mind map content properly represents research findings with accurate categorization and logical grouping. Primary branches should represent major research areas, with sub-branches showing detailed findings and relationships. Deduct 5 points if major research components are missing, 3 points if the categorization is misleading. Full score requires comprehensive representation of all key findings with proper context and relationships.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the markmap interactive and user-friendly?",
-      "description": "Check whether the implementation includes essential interactive features like node expansion/collapse, zooming, panning, and clickable elements. Evaluate if the mind map responds to user interactions properly. Deduct 5 points if basic interactivity is missing, 3 points if the interaction is sluggish or unintuitive. Full points require smooth, intuitive interactions with appropriate visual feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed data, browser compatibility issues, rendering failures) and provide fallback mechanisms. Code with strong robustness should include error handling, browser feature detection, and graceful degradation. Give 10 points if comprehensive error handling exists, 5 points if basic error handling is present, and 0 points if no exception handling is implemented.",
-      "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. Custom node styling based on content type 2. Search/filter functionality for large mind maps 3. Export options to different formats). 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 visualization libraries loaded but not used 2. Function modules unrelated to mind mapping 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating data handling/visualization/interaction layers), code reusability, and optimization techniques. Deduct 5 points if global variable pollution is found or proper encapsulation is not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no performance optimizations are implemented for large mind maps. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the mind map visualization follows modern design principles: 1) Harmonious color scheme for different hierarchy levels 2) Proper spacing between nodes and branches 3) Professional typography with readable font sizes and appropriate contrast. Deduct 3 points for cluttered node placement, 5 points for poor color choices that hinder readability, and 5 points for inconsistent visual hierarchy. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the mind map interactions conform to human perception characteristics: 1) Node expansion/collapse animations between 200-400ms 2) Smooth zooming and panning without visual stuttering 3) Clear visual focus indication for selected nodes. Deduct 5 points for jerky animations, 3 points for delayed response to user input, and 5 points for confusing state changes during interactions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Mermaid Flowcharts-Mind Maps",
-  "difficulty": "easy"
-}

package/library/mermaid_flowcharts-mind_maps/study-guide-mind-map-generator.json

@@ -1,68 +0,0 @@
-{
-  "index": 1214,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable. I need a piece of code that can create a mind map. I have a PDF file called \"《Chinese Modern Literature: Thirty Years》Study Guide_11950065\". My requirement is to organize the key points, difficult areas, required reading lists, timeline events, authors and their works, as well as their literary significance mentioned in the file, and create a mind map from this information. Please generate a complete, runnable code for me.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the mind map core structure implementation complete?",
-      "description": "Review whether the code implements a tree data structure to support the hierarchical organization of mind map nodes and provides methods to add, delete, edit, and navigate these nodes. Check if the data model logically separates nodes, connections, and content. Score 0 if fundamental mind map structure is missing, 5 if a basic tree structure is implemented but lacks manipulation functions, and 10 if a robust hierarchical data structure with full CRUD operations is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the code provide PDF parsing and content extraction functionality?",
-      "description": "Examine whether the code includes reliable PDF parsing capabilities (e.g., using libraries like pdf.js, pdfminer, PyPDF2) that extract text content, identify headings/sections, and recognize structural elements from the '《Chinese Modern Literature: Thirty Years》Study Guide'. Deduct 5 points if only basic text extraction is implemented without structure recognition, deduct 3 points if the extraction fails to handle Chinese characters properly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there intelligent content categorization for Chinese literature elements?",
-      "description": "Assess whether the code contains algorithms or patterns to automatically identify and categorize key literary elements (key points, difficult areas, reading lists, timeline events, authors and works, literary significance) from the extracted text. Check for natural language processing techniques or rule-based systems to organize content. Score 0 if no categorization exists, 5 if basic keyword matching is used, and 10 if sophisticated content analysis with context awareness is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the visualization component effectively render the mind map?",
-      "description": "Evaluate the quality of the mind map rendering - check if it uses appropriate libraries (D3.js, GoJS, vis.js) or implements custom graphics rendering. The visualization should support zooming, panning, and proper hierarchical layout with Chinese text rendering. Deduct 5 points if the layout algorithm results in overlapping nodes, 3 points if zoom/pan controls are missing, and 5 points if Chinese characters display incorrectly. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code handles common error cases (invalid PDF format, parsing failures, empty sections, memory limitations with large files) and provides appropriate error messages or recovery mechanisms. Code with strong robustness should properly validate inputs, handle Unicode/Chinese characters correctly, and manage memory efficiently. Score 10 for comprehensive error handling, 5 for basic validation, and 0 if critical errors 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. Auto-summarization of literary concepts 2. Integration with literature databases for additional context 3. Timeline visualization for historical literary events 4. Author relationship network visualization). 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 data processing pipelines (multiple text extraction methods without clear purpose) 2. Feature modules unrelated to literature mind mapping (e.g., built-in document editor) 3. Excessive visual effects that impact performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if core mind mapping functionality is compromised by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separation of PDF parsing, data processing, mind map visualization), code reusability, documentation quality, and development workflow integration. Deduct 5 points if global variables are overused or module boundaries are unclear; deduct 5 points if code duplication exceeds 30%; deduct 5 points if documentation is insufficient for complex functions. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the mind map design follows modern visualization principles: 1) Appropriate use of color to distinguish different categories of literature concepts 2) Clear hierarchical spacing between mind map levels 3) Legible typography for Chinese text (appropriate font choice, sufficient size). Deduct 3 points for visually cluttered node arrangements, 5 points for poor color contrast that affects readability, and 5 points for improper handling of long Chinese text. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the mind map interactions suit user expectations: 1) Responsive node expansion/collapse (≤100ms) 2) Smooth transitions when navigating between different levels (300-500ms) 3) Intuitive controls for reorganizing nodes. Deduct 5 points for laggy rendering with many nodes, 3 points for jarring transitions between mind map states, and 5 points for unintuitive node manipulation controls. Full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Mermaid Flowcharts-Mind Maps",
-  "difficulty": "medium"
-}