@getollie/cli 0.0.1

package/library/utility_tools-automation/implement-ssh-terminal-tauri-vue3-xterm.json

@@ -0,0 +1,68 @@
+{
+  "index": 709,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for demonstration. How can I use Xterm.js to implement a terminal for Vue and Gin projects—connecting to a remote server and controlling it? Please provide me with complete code (as fully functional as possible).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Xterm.js integration with Vue.js correctly implemented?",
+      "description": "Check whether the Xterm.js terminal is properly initialized in a Vue component with essential options (cursorBlink, fontSize, theme configuration). Verify event handling setup for terminal input/output. Score 0 if terminal isn't functional, 5 if basic terminal display works but lacks essential options, and 10 if the terminal is fully configured with proper lifecycle management (mounted/destroyed hooks, resize handling).",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the WebSocket connection to the Gin backend properly implemented?",
+      "description": "Evaluate the WebSocket connection implementation between Vue frontend and Gin backend, including connection establishment, message handling, and error handling. Connection must include authentication mechanism and reconnection strategy. Deduct 5 points if authentication is missing, 3 points if reconnection strategy is incomplete, and 2 points if there's no connection status indicator. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the Gin backend properly handling terminal sessions?",
+      "description": "Review the Gin backend implementation for terminal sessions, including session creation/management, command execution, and output streaming. Check for TTY allocation, proper environment variables setting, and signal handling (SIGINT, SIGTERM). Deduct 5 points if process management is incomplete, 3 points if session persistence isn't implemented, and 5 points if security measures are inadequate. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the SSH/remote terminal connection properly implemented?",
+      "description": "Assess the implementation of SSH/remote terminal connection, including authentication methods (password, key-based), session management, and terminal resizing capabilities. Verify proper handling of different shell environments and terminal types. Deduct 5 points if authentication options are limited, 3 points if terminal resize isn't handled, and 5 points if connection state management is missing. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (network disconnection, authentication failures, server errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases like connection timeouts, unexpected terminal exits, and concurrent users, 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. Terminal session recording/playback 2. Split terminal functionality 3. Command history with search 4. Syntax highlighting for common commands 5. Auto-completion). 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 connect to a server) 2. Function modules unrelated to terminal functionality (e.g., a built-in file manager when not needed) 3. Fancy effects that affect performance (e.g., excessive animations in the terminal UI). 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 (separating terminal logic/UI/network layers), clear component structure, code comments, and error handling. Deduct 5 points if global state management is misused; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no proper error logging system. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional terminal standards?",
+      "description": "Evaluate whether the terminal interface follows professional design principles: 1) Proper color scheme with good contrast 2) Monospace font with appropriate size and line height 3) Clear cursor visibility and blinking options 4) Responsive design that adapts to container size. Deduct 3 points for poor text readability, 5 points for a cluttered interface with unnecessary elements, and 5 points for non-responsive terminal dimensions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the terminal interaction smooth and responsive?",
+      "description": "Judge whether the terminal interaction conforms to expected behavior: 1) Input latency ≤ 100ms 2) Smooth scrolling without flickering 3) Proper handling of keyboard shortcuts and special keys (Ctrl+C, arrow keys, Tab). Deduct 5 points for noticeable input lag, 3 points for rendering issues during rapid output, and 5 points for incorrect handling of special keys or key combinations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Hardware Management",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/javascript-search-autocomplete-chinese-pinyin-english.json

@@ -0,0 +1,68 @@
+{
+  "index": 896,
+  "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 whenever possible. Please use JavaScript to implement a search autocomplete system that can recognize Chinese characters, Pinyin, and English.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Chinese character recognition and search functionality fully implemented?",
+      "description": "Review whether the code accurately implements Chinese character matching, including full character matching, partial character matching, and radical-based search. Check if it supports traditional and simplified Chinese conversion, and handles polyphone characters correctly. Score 0 if basic Chinese recognition is missing, 5 if only simple character matching is implemented, and 10 if comprehensive Chinese character processing including stroke order and radical recognition is fully supported.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Pinyin input recognition system comprehensively implemented?",
+      "description": "Evaluate whether the Pinyin recognition includes tone handling (with and without tone marks), fuzzy Pinyin matching (zh/z, ch/c, sh/s confusion), and initial letter abbreviation search. Check if it supports both full Pinyin and abbreviated Pinyin input modes. Deduct 5 points if tone-insensitive matching is missing, and 3 points if fuzzy matching for common Pinyin confusions is not handled. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the multilingual mixed search capability properly designed?",
+      "description": "Check whether the system can handle mixed input of Chinese, Pinyin, and English simultaneously within a single search query. Evaluate the accuracy of language detection and switching algorithms, and whether cross-language matching is supported (e.g., English keywords matching Chinese results). Deduct 5 points if language switching has noticeable delays, and 3 points if mixed input causes search conflicts. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the autocomplete suggestion algorithm optimized for performance?",
+      "description": "Review whether the autocomplete system implements efficient data structures like Trie trees or similar for fast prefix matching, includes debouncing mechanisms for user input, and provides ranked suggestions based on relevance and frequency. Check if caching strategies are implemented for common queries. Deduct 5 points if response time exceeds 200ms for typical queries, and 5 points if no input optimization techniques are used. Give 10 points if fully optimized.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid Unicode characters, mixed encoding input, network timeouts, malformed search queries, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases like empty inputs, extremely long queries, and special characters, 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 search experience (e.g., 1. Voice input with speech-to-text for Chinese/English 2. Smart typo correction and suggestion 3. Semantic search with context understanding 4. Historical search pattern learning). 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 search algorithms (e.g., multiple Pinyin conversion libraries coexisting) 2. Function modules unrelated to search autocomplete (e.g., built-in translation services) 3. Fancy effects that affect search performance (e.g., heavy animations during typing). Deduct 3 points for each redundancy found, and directly deduct 10 points if core search 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 search logic/data processing/UI layers), unit test coverage for different language inputs, and build process automation. 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 build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional standards?",
+      "description": "Evaluate whether the search interface follows modern design principles: 1) Harmonious color matching with proper contrast ratios for text readability 2) Appropriate dropdown suggestion spacing (minimum 44px touch targets) 3) Professional typography supporting multilingual display (proper font fallbacks for Chinese characters). Deduct 3 points for each crowded visual element, 5 points for poor text legibility in suggestions, and 5 points for inconsistent multilingual text alignment. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the search interaction smooth and responsive?",
+      "description": "Judge whether the search experience meets usability standards: 1) Input response delay ≤ 100ms 2) Suggestion dropdown appears within 200ms 3) Smooth keyboard navigation (arrow keys, enter, escape) 4) Clear visual feedback for selection states. Deduct 5 points for each laggy interaction, 3 points for missing keyboard accessibility, and 5 points for unclear selection indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

package/library/utility_tools-automation/mini-program-auto-extract-geo-coordinates-from-screenshots.json

@@ -0,0 +1,68 @@
+{
+  "index": 954,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration purposes. I am a programming novice. How can I create a mini-program that automatically extracts precise latitude and longitude coordinates from uploaded location screenshots? Please automatically generate the code for me and provide detailed step-by-step instructions.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image processing and OCR functionality properly implemented?",
+      "description": "Evaluate whether the code includes robust image processing capabilities (like OpenCV) to handle various screenshot formats and OCR library integration (like Tesseract) to extract text from images. Check if preprocessing steps like image resizing, normalization, and noise reduction are included. Score 0 if image processing is absent, 5 if basic functionality exists but handles limited formats, and 10 if comprehensive processing with format validation is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the coordinate extraction logic comprehensive and accurate?",
+      "description": "Check whether the code can recognize different coordinate formats (decimal degrees, DMS, UTM) and extract them accurately using regex patterns or other text analysis methods. Verify if the implementation can handle different map service screenshots (Google Maps, Apple Maps, etc.). Deduct 5 points if only one coordinate format is supported, 3 points if extraction accuracy is below 90%. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the user interface intuitive and beginner-friendly?",
+      "description": "Assess whether the interface provides clear upload mechanisms, progress indicators, and result displays appropriate for a programming novice. Check if there are visual cues for successful/failed operations. Deduct 5 points if the interface requires coding knowledge to operate, 3 points if feedback on processing status is unclear. Give 10 points if the interface is completely self-explanatory.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are there validation and error handling mechanisms for coordinate extraction?",
+      "description": "Evaluate whether the code validates extracted coordinates (checking range: latitude -90 to 90, longitude -180 to 180) and provides meaningful error messages for images without coordinates or with unreadable text. Look for fallback mechanisms when primary extraction fails. Deduct 5 points if validation is absent, 3 points if error messages are generic or unhelpful. 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 corrupted images, wrong file types, extraction failures, 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. Automatic map service detection 2. Reverse geocoding to show address from coordinates 3. Batch processing multiple screenshots). 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 OCR engines doing the same job) 2. Function modules unrelated to coordinate extraction (e.g., a built-in image editor) 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 UI/processing/validation logic), error handling, 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 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 (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) Processing feedback delay ≤ 2 seconds for standard images 2) Clear progress indicators for longer operations 3) Intuitive drag-and-drop or file selection interfaces. Deduct 5 points for each operation without feedback, 3 points for processing times over 5 seconds without indicators, and 5 points for confusing upload or download mechanisms. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

package/library/utility_tools-automation/monitor-chext-transactions-mobile.json

@@ -0,0 +1,68 @@
+{
+  "index": 1422,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional responses. Take care to ensure the code you produce is executable when displayed. Write a program that can monitor in real-time single transactions equal to 300,000 shares (3,000 lots) on the ChiNext (Growth Enterprise Market) board stocks on mobile phones, excluding ST stocks.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the real-time stock monitoring system properly implemented?",
+      "description": "Review whether the code accurately implements a real-time monitoring system that tracks ChiNext board stocks with transactions of exactly 300,000 shares (3,000 lots), with proper filtering for ST stocks. The implementation should include data retrieval, filtering logic, and appropriate triggers when conditions are met. Score 0 if core monitoring logic is missing, 5 if basic monitoring is implemented but with deficiencies, and 10 if all requirements are fully satisfied with efficient algorithms.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the data source connection and real-time updates properly handled?",
+      "description": "Check whether the implementation connects to a reliable stock market data feed (like an API from a financial data provider), handles connection management, implements proper polling or WebSocket for real-time updates, and includes error handling for connection issues. Deduct 5 points if data retrieval is not real-time or lacks reliability mechanisms, and 3 points if error handling for network issues is insufficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the ChiNext board filtering and ST stock exclusion properly implemented?",
+      "description": "Evaluate whether the code correctly identifies ChiNext board stocks (usually by stock code prefix or through API parameters) and properly filters out ST stocks. The implementation should account for changes in stock status and maintain an updated list. Deduct 5 points if the ChiNext filtering is inaccurate, and 5 points if ST stock exclusion logic is missing or flawed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the 300,000 shares (3,000 lots) transaction detection accurate?",
+      "description": "Check if the code precisely detects single transactions equal to exactly 300,000 shares, not aggregated multiple smaller transactions. The implementation should distinguish between normal trading volume and the specific transaction size being monitored. Deduct 5 points if the detection cannot differentiate between single large transactions and accumulated volume, and 5 points if the volume calculation contains errors or ambiguities. 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 market data delays, API failures, irregular trading hours, trading halts, etc.) and provides 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. Historical pattern analysis of 300,000-share transactions 2. Auto-correlation with news events when large transactions occur 3. Visual heatmaps of transaction frequency by stock). 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 notification systems) 2. Function modules unrelated to stock monitoring (e.g., a built-in general news reader) 3. Fancy effects that affect performance (e.g., excessive animations that drain battery). 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 retrieval/processing/notification layers), unit test coverage, and mobile-specific optimizations for battery and data usage. 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 mobile-specific optimizations are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the mobile interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern mobile design principles: 1) Harmonious color matching suitable for financial applications (no more than 3 primary colors) 2) Proper layout spacing for touch targets (at least 44x44pt) 3) Professional font system (body font size ≥ 16px for readability). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for poorly organized data presentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the mobile notification and alert system effective?",
+      "description": "Judge whether the alert system for detected transactions is properly implemented for mobile: 1) Immediate push notifications when transactions are detected 2) Configurable alert sounds/vibrations 3) Background operation capability with battery optimization. Deduct 5 points for notifications with >5 second delay, 3 points for lack of configuration options, and 5 points for excessive battery drain in background mode. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/monorepo-vue3-vite-tailwind-v4-setup.json

@@ -0,0 +1,68 @@
+{
+  "index": 354,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be careful to ensure that the generated code is executable and can be demonstrated. In a monorepo Vue3 Vite Tailwind V4 project, sub-projects in the apps directory and common components stored in the components directory under packages/core can all use Tailwind V4.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the monorepo structure correctly configured for Vue3, Vite, and Tailwind v4?",
+      "description": "Review the project structure to ensure it follows best practices for a monorepo with proper directory organization (apps directory for sub-projects, packages/core for common components). Check if package.json contains correct workspaces configuration, and if the root configuration properly references all workspace packages. Score 0 if the basic structure is incorrect, 5 if structure exists but with configuration issues, 10 if perfectly organized.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are Vite configurations properly set up across the monorepo?",
+      "description": "Examine if vite.config.js/ts files are properly configured at both root and sub-project levels with correct aliases, build options, and plugins. Check if path resolution works correctly between packages. Verify that each sub-project can independently build and run. Deduct 5 points if build dependencies are incorrectly configured, and 3 points if hot module replacement doesn't work across packages. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is Tailwind v4 correctly integrated across all packages and apps?",
+      "description": "Verify that tailwind.config.js is properly configured at the root level and/or in each sub-project with correct content paths. Check if Tailwind directives (@tailwind base, components, utilities) are properly imported in main CSS files. Verify that utility classes work in both apps and shared components. Deduct 5 points if there are conflicting configurations, deduct 3 points if custom theme values aren't properly shared. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are shared components in packages/core accessible and styled correctly across sub-projects?",
+      "description": "Check if components in packages/core are properly exported and can be imported in apps. Verify that Tailwind classes are applied correctly in shared components and maintain consistent styling across different sub-projects. Ensure component props are properly typed with TypeScript. Deduct 5 points for component import issues, deduct 3 points for inconsistent styling behavior. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as missing props, network interruptions, component loading errors, etc.) and provide friendly error prompts or fallbacks. Code with strong robustness should show error boundaries in Vue components, defensive coding patterns, and proper error handling. Give 10 points for comprehensive error handling, 5 points for basic error handling, and 0 points if no error handling exists.",
+      "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 development experience (e.g., 1. Custom Vite plugins for the monorepo 2. Shared state management solution across apps 3. Automated component documentation). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Duplicate dependencies across packages (e.g., multiple versions of Vue) 2. Redundant configuration files (e.g., multiple ESLint configs with similar rules) 3. Unnecessary build steps that slow down development. Deduct 3 points for each redundancy found, and directly deduct 10 points if core functionality is compromised by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as proper separation of concerns in components), TypeScript usage quality, test coverage, and CI/CD configuration. Deduct 5 points if global state is used inappropriately; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no automated tests. 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) Consistent use of Tailwind utility classes following the design system 2) Proper spacing and layout (using Tailwind's spacing scale consistently) 3) Professional typography (using appropriate text sizes and line heights from the Tailwind config). Deduct 3 points for inconsistent spacing, 5 points for accessibility issues (contrast, focus states), and 5 points for chaotic responsive layouts. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the Vue components provide smooth interaction: 1) Proper use of transitions and animations 2) Optimized rendering with proper use of v-memo, shallowRef, etc. 3) Efficient loading strategies (lazy loading where appropriate). Deduct 5 points for jank during interactions, 3 points for memory leaks from improper cleanup, and 5 points for poor performance when navigating between sub-apps. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

package/library/utility_tools-automation/multi-window-typescript-framework-no-vue.json

@@ -0,0 +1,68 @@
+{
+  "index": 1078,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate, professional responses. Be careful to ensure that any code you generate is executable. I want to build a multi-window framework in TypeScript, without using Vue.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Does the multi-window framework implement a complete window management system?",
+      "description": "Review whether the code implements the basic components of a window system: window creation, positioning, resizing, maximizing, minimizing, closing, and z-index management. Score 0 if window creation and manipulation are not implemented, 5 if only basic operations are available, and 10 if all standard window behaviors (including snapping, restoring state) are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is window state management properly implemented?",
+      "description": "Evaluate the implementation of window state tracking and persistence. Check for a centralized state management system that handles window positions, sizes, visibility, focus state, and stacking order. Look for proper event handling and state transitions. Deduct 3 points if window states are not properly persisted, 3 points if focus management is incorrect, and 4 points if state transitions are buggy or inconsistent.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the framework provide flexible content rendering and communication between windows?",
+      "description": "Check if the framework allows dynamic content loading within windows and implements inter-window communication. Test if windows can exchange messages, share data, or access common services. Award full points if both iframe support and a messaging API are implemented with proper type safety. Deduct 5 points if windows are isolated with no communication mechanism, and 3 points if the communication is poorly typed or unreliable.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the TypeScript implementation well-typed and does it leverage TypeScript's features effectively?",
+      "description": "Review the TypeScript implementation for proper typing, interfaces/types for window configurations, proper use of generics, and type safety across the framework. Evaluate if the code leverages TypeScript features like discriminated unions, mapped types, or conditional types where appropriate. Deduct 5 points for any use of 'any' type, 3 points for insufficient interfaces/types, and 2 points for not using TypeScript features that would improve the code.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid window configurations, DOM manipulation errors, event race conditions, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should prevent window states from becoming corrupted and handle edge cases like rapid window operations or browser limitations. Give 10 points for comprehensive error handling, 5 points for basic error handling, and 0 points if exceptions are not managed.",
+      "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. Window grouping or tabbing 2. Window templates with predefined behaviors 3. Animated transitions between window states 4. Window theming system). 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 functionality (e.g., multiple window management systems) 2. Unnecessary abstractions that complicate the codebase 3. Performance-heavy features that aren't essential to window management (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if core window functions are negatively impacted by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating core functionality, UI rendering, event handling), test coverage, and build process. Check for proper dependency management, code organization, and documentation. Deduct 5 points if global state is poorly managed; deduct 5 points if code duplication rate is high (over 30%); deduct 5 points if there's no build configuration or it's inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the window design follows modern UI principles: 1) Consistent window chrome design (title bars, borders, controls) 2) Proper spacing and alignment of window elements 3) Professional and accessible controls with proper sizing and hover states. Deduct 3 points for inconsistent window styling, 5 points for poor accessibility in window controls, and 5 points for awkward or unnatural window behaviors. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the window interaction smooth and responsive?",
+      "description": "Judge whether window operations feel natural and responsive: 1) Window creation/closing animations under 300ms 2) Dragging/resizing with no perceptible lag 3) Proper cursor feedback during window operations. Deduct 5 points for jittery window movement, 3 points for slow or delayed responses to user input, and 5 points for any operation that freezes the UI for more than 100ms. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "medium"
+}

package/library/utility_tools-automation/network-packet-capture-analysis-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 570,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Develop a network packet capture and analysis tool that can capture HTTP/HTTPS requests and responses in the browser, displaying information such as request headers, response bodies, and time consumption. Support filtering requests by URL, status code, content type, and other conditions, and allow exporting captured data in HAR format. Provide request replay and editing functionality.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the network packet capture mechanism fully implemented?",
+      "description": "Review whether the code accurately implements HTTP/HTTPS request interception using browser APIs (such as chrome.webRequest, Service Worker, or browser DevTools Protocol). Check if it includes complete capture of request/response headers, body content, timing information, and WebSocket connections. Score 0 if core capture functionality is missing, 5 if only basic HTTP requests are captured, and 10 if comprehensive packet capture including HTTPS, redirects, and error responses is fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the real-time analysis and display system implemented?",
+      "description": "Evaluate whether the implementation includes real-time parsing and display of captured packets with detailed information (headers, payload, timing, size). Check for proper handling of different content types (JSON, XML, images, etc.) and encoding formats. Deduct 5 points if response body parsing is incomplete, and 3 points if timing analysis lacks precision. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are comprehensive filtering and search capabilities provided?",
+      "description": "Check whether the filtering system supports multiple criteria including URL patterns, HTTP methods, status codes, content types, request size, and custom header values. Evaluate if advanced search features like regex matching and boolean operators are implemented. Deduct 5 points if filtering is limited to basic criteria only, and 3 points if search performance is poor with large datasets. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are HAR export and request replay functions fully constructed?",
+      "description": "Verify whether the code includes complete HAR (HTTP Archive) format export functionality with proper JSON structure and all required fields. Check if request replay and editing features allow modification of headers, parameters, and body content with validation. Deduct 5 points if HAR export is incomplete or invalid, and 5 points if replay functionality lacks proper error handling. Give 10 points if fully implemented with import/export capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed requests, large payloads, network timeouts, browser permission denials, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases including memory management for large captures. Give 10 points for comprehensive error handling, 5 points if robustness is average, and 0 points if no exceptions are handled.",
+      "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 analysis experience (e.g., 1. Real-time network performance metrics and visualization 2. Automatic API documentation generation from captured requests 3. Request diff comparison tools 4. Security vulnerability detection). 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 capture mechanisms (e.g., multiple packet capture libraries coexisting) 2. Function modules unrelated to network analysis (e.g., built-in text editor with full IDE features) 3. Excessive visual effects that impact performance (e.g., real-time 3D network topology animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if core analysis 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 capture engine/analysis logic/UI layers), memory management for large datasets, and performance optimization. Deduct 5 points if memory leaks are found or inefficient data structures are used; deduct 5 points if the code lacks proper architecture patterns; deduct 5 points if there's no consideration for handling high-volume traffic. 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 for developer tools: 1) Harmonious color coding for different HTTP methods and status codes 2) Proper layout with collapsible panels and efficient space usage 3) Professional monospace fonts for code display and proper syntax highlighting. Deduct 3 points for each cluttered data visualization, 5 points for poor color contrast affecting readability, and 5 points for chaotic information hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the interface handles real-time data updates efficiently: 1) Live packet capture display without UI freezing 2) Smooth scrolling through large datasets with virtualization 3) Responsive filtering and search with debounced input 4) Quick access to detailed packet information. Deduct 5 points for each laggy interaction during high-traffic capture, 3 points for delayed search results, and 5 points for unresponsive UI during data processing. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}

package/library/utility_tools-automation/photoshop-2025-one-click-photo-cutout-jsx-script.json

@@ -0,0 +1,68 @@
+{
+  "index": 1161,
+  "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. Create a JSX script for one-click photo cutout in Photoshop 2025.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the JSX script structure and Photoshop API integration correctly implemented?",
+      "description": "Review whether the JSX script properly uses Photoshop's ExtendScript API, includes correct app.activeDocument references, and implements proper layer manipulation methods. Check if the script handles document validation, layer creation, and selection operations according to Photoshop 2025 specifications. Score 0 if basic Photoshop objects are not accessed, 5 if only simple operations work, and 10 if all core Photoshop APIs are properly integrated with error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the automated cutout algorithm implementation effective and accurate?",
+      "description": "Evaluate whether the script implements intelligent subject detection using Photoshop's built-in AI features (like 'Select Subject' or 'Remove Background'), includes edge refinement algorithms, and handles complex backgrounds. Check if the script uses proper selection methods like colorRange(), contract(), expand(), and feather() for precise cutouts. Deduct 5 points if edge detection is poor, 3 points if transparency handling is incomplete. Full score requires advanced selection refinement and multi-layer support.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the one-click workflow optimization properly designed with batch processing capability?",
+      "description": "Check whether the script provides true one-click functionality with minimal user intervention, includes batch processing for multiple images, and implements proper file handling (open, save, export). Evaluate if the script supports different input formats, automatic output naming conventions, and progress tracking. Deduct 5 points if manual intervention is required for each image, 3 points if batch processing fails on different file types. Full score requires seamless automation with robust file management.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is comprehensive user preference and output format management implemented?",
+      "description": "Assess whether the script includes user-configurable settings (output format, quality, transparency options), supports multiple export formats (PNG, PSD, TIFF), and provides preview functionality before final processing. Check if the script remembers user preferences, includes undo functionality, and handles different color modes. Deduct 5 points if only basic PNG export is supported, 3 points if no user customization options exist. Full score requires complete preference management and format flexibility.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as locked layers, no active document, unsupported file formats, memory limitations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include try-catch blocks, proper error logging, and graceful degradation. Give 10 points if fully robust, 5 points if basic error handling exists, and 0 points if no exception handling is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that enhance the cutout workflow?",
+      "description": "Check whether the code includes advanced features that improve the cutout experience (e.g., 1. Hair/fur detail preservation algorithms 2. Smart background replacement suggestions 3. Automatic edge color correction 4. Batch watermark removal 5. AI-powered subject recognition training). Add 3 points for each practical innovative feature implemented that goes beyond basic cutout functionality (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant selection methods (e.g., multiple similar cutout algorithms running simultaneously) 2. Unrelated image editing features (e.g., built-in filters or artistic effects) 3. Performance-heavy operations that don't improve cutout quality (e.g., unnecessary high-resolution previews). Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code significantly impacts script performance or core functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating selection logic, file handling, and UI components), proper function organization, and code maintainability. Check for consistent naming conventions, adequate commenting, and reusable function structures. Deduct 5 points if global variable pollution is found or no modular pattern is used; deduct 5 points if code duplication rate exceeds 30%; deduct 5 points if functions are not properly documented or organized. Full score requires clean, maintainable architecture.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the user interface (if implemented) meet professional design standards?",
+      "description": "If the script includes a UI panel, evaluate whether it follows Adobe's design guidelines: 1) Consistent with Photoshop's native UI styling 2) Proper spacing and alignment (following 4px grid system) 3) Clear button hierarchy and iconography 4) Appropriate color scheme matching Photoshop's theme. Deduct 3 points for each UI element that doesn't match Adobe standards, 5 points for poor visual hierarchy, and 5 points for confusing layout. Full score for native-looking, intuitive interface.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the script performance optimized and processing feedback clear?",
+      "description": "Judge whether the script provides clear processing feedback: 1) Progress indicators during cutout operations 2) Processing time optimization for large files 3) Memory usage management 4) Clear status messages and completion notifications. Deduct 5 points for each operation without user feedback, 3 points if processing hangs on large files without indication, and 5 points if memory usage is not optimized. Full score requires smooth performance with comprehensive user feedback throughout the process.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Utility Tools-Automation",
+  "difficulty": "hard"
+}