A sophisticated userscript that integrates with WTR-Lab's "For You" pages to provide AI-powered novel analysis using Google Gemini. Features comprehensive literary assessments including character development, plot structure, world-building, themes & messages, and writing style analysis with intelligent batch processing and advanced caching mechanisms.

• 🎯 Overview
• ✨ Features
• 🚀 Quick Start
• 🔧 Installation
• ⚙️ Configuration
• 💻 Usage Guide
• 🛠️ Development Setup
• 📦 Build System
• 🏗️ Project Structure
• 🧪 Testing
• 🐛 Troubleshooting
• 🤝 Contributing
• 📊 Technical Architecture
• 🔄 API Integration
• 📈 Performance Optimization
• 🛡️ Security Considerations
• 📝 Changelog
• 📄 License
• 🙏 Acknowledgments
• 💬 Support

The WTR-Lab Novel Reviewer is an advanced userscript that enhances the WTR-Lab reading experience by providing AI-powered literary analysis. Built with modern web technologies and optimized for performance, it seamlessly integrates with WTR-Lab's interface to deliver comprehensive novel assessments using Google's Gemini AI.

Key Differentiators:

• Intelligent Batch Processing: Optimized API usage with smart pagination (60-80% reduction in unnecessary calls)
• Advanced Caching: Local storage-based caching prevents redundant API requests with dedicated cache management
• Color-Coded UI: Accessible 20-color palette for username attribution and assessment visualization
• Robust Error Handling: Comprehensive retry logic with mapping validation safeguards
• Modern Architecture: Built with Webpack, ESLint, Prettier, and automated version management
• Enhanced UI/UX: Complete interface modernization with responsive design and mobile optimization
• Multi-Route Support: Full support for both "For You" and "Novel Finder" pages with reactive route handling
• Reactive Navigation: Automatic script re-initialization on client-side route changes in Next.js SPA environment

• Comprehensive Literary Assessment: Multi-category analysis using Google's Gemini AI
• Five Assessment Categories:
  • Character Development: Character depth, growth, consistency, dialogue authenticity
  • Plot Structure: Pacing, narrative flow, story coherence, conflict resolution
  • World-Building: Setting details, consistency, immersion, cultural depth
  • Themes & Messages: Clarity, relevance, integration, thought provocation
  • Writing Style: Prose quality, descriptive language, dialogue naturalness
• Intelligent Rating System: Good/Mixed/Bad/Unknown (for insufficient data)
• Single Novel Processing: Optimized to process one novel at a time for better control

• Color-Coded Review Summaries: Username attribution with 20-color accessible palette
• Card Highlighting: Background colors indicate overall assessment (Dark Green/Yellow/Red)
• Interactive UI Components: Collapsible summaries with smooth animations
• Modernized Interface: Complete UI/UX modernization with contemporary design patterns
• Mobile Responsive: Optimized display for all screen sizes with modal overlay functionality
• Accessibility: Color-blind friendly design with proper contrast ratios

• Smart Caching System: Local storage caching prevents redundant API calls
• Cache Management: Dedicated cache clearing functionality with user confirmation
• Context-Aware UI: Button functionality adapts based on novel analysis state
• Serie ID Mapping: Robust validation system prevents processing errors
• Error Recovery: Comprehensive retry logic with exponential backoff
• Debug Mode: Optional detailed logging for troubleshooting
• Performance Optimization: 60-80% reduction in unnecessary API calls through smart pagination
• Multi-Route Support: Full integration with "For You" and "Novel Finder" pages
• Reactive Execution: Automatic script re-initialization on client-side route changes
• Route Whitelisting: Prevents processing on unsupported pages for better performance

• Modal Overlay: AI Summary Panel displays as fixed overlay on mobile screens (≤768px)
• Touch-Optimized: Improved button sizing and spacing for mobile interactions
• Responsive Design: Advanced responsive patterns ensuring optimal viewing on all devices
• Cross-Device Consistency: Unified design system implementation across all screen sizes

1. Install Tampermonkey or Violentmonkey browser extension
2. Get a Gemini API Key from Google AI Studio
3. Install the script from Greasy Fork
4. Configure API key in the settings panel
5. Navigate to WTR-Lab "For You" or "Novel Finder" page and click the analysis button on individual novel cards
6. Enjoy seamless navigation - the script automatically handles client-side route changes

# Clone the repository
git clone https://github.com/MasuRii/wtr-lab-novel-reviewer.git
cd wtr-lab-novel-reviewer

# Install dependencies
npm install

# Start development server
npm run dev

# Build for production
npm run build

• Node.js (v16 or higher)
• npm (v8 or higher)
• Userscript Manager: Tampermonkey or Violentmonkey
• Gemini API Key: Free tier available from Google AI Studio

git clone https://github.com/MasuRii/wtr-lab-novel-reviewer.git
cd wtr-lab-novel-reviewer

npm install

# Start development server with hot-reloading
npm run dev

# Build development bundle (for testing)
npm run build:devbundle

# Build for production
npm run build

# Build for GreasyFork distribution
npm run build:greasyfork

1. Start the development server: npm run dev
2. The proxy script will be available at dist/wtr-lab-novel-reviewer.proxy.user.js
3. Install this proxy script in Tampermonkey for automatic updates

The script supports multiple Gemini models with different performance characteristics:

const GEMINI_MODELS = [
  'gemini-2.5-pro',        // Most powerful, higher cost
  'gemini-2.5-flash',      // Fast and cost-effective (default)
  'gemini-flash-latest',   // Latest flash model
  'gemini-flash-lite-latest', // Ultra-fast for quick assessments
  'gemini-2.5-flash-lite'  // Lightweight version
];

# Optional environment overrides
WTR_VERSION=1.8.4          # Version override
WTR_BUILD_ENV=production   # Build environment
WTR_BUILD_DATE=2025-11-16  # Build date override

1. Navigate to WTR-Lab "For You" page or WTR-Lab "Novel Finder" page
2. Click the analysis button (📊) in the top-right corner of novel card titles
3. View AI assessments displayed as colored icons on novel cards
4. Hover over the ✨ icon to see detailed analysis summaries
5. Navigate between pages and enjoy seamless script re-initialization
6. Clear Cache using the dedicated button in settings when needed

• "Analyze Novel": For novels without cached analysis
• "Show AI Summary": For novels with cached analysis
• Adaptive Tooltips: Button text changes based on novel state
• Individual Control: Each novel card has its own analysis trigger

• Selective Clearing: Clear only geminiAssessment_* prefixed keys
• User Confirmation: Prevents accidental data loss
• Visual Feedback: Success/failure notifications during clearing
• Automatic Refresh: Page reloads after successful cache clearing

• Dark Green Cards: Good overall assessment
• Dark Yellow Cards: Mixed quality (average with issues)
• Dark Red Cards: Poor quality (problematic content)

The script uses a deterministic 20-color palette for consistent username colors:

const USERNAME_COLORS = [
  '#e74c3c', '#3498db', '#2ecc71', '#f39c12', '#9b59b6',
  '#1abc9c', '#e67e22', '#34495e', '#e91e63', '#ff5722',
  // ... 10 more colors for consistent attribution
];

• Automatic: Assessments cached locally to prevent redundant API calls
• Persistent: Cached data survives page reloads and browser sessions
• Validation: Automatic structure validation ensures data integrity
• Management: User-controlled cache clearing with confirmation prompts

• Node.js v16+ and npm v8+
• Git for version control
• Modern Code Editor (VS Code recommended)

{
  "devDependencies": {
    "webpack": "^5.102.1",
    "webpack-cli": "^6.0.1",
    "webpack-dev-server": "^5.2.2",
    "webpack-userscript": "^3.2.3",
    "eslint": "^9.39.1",
    "prettier": "^3.6.2",
    "stylelint": "^16.25.0",
    "css-loader": "^7.1.2",
    "style-loader": "^4.0.0"
  }
}

The project enforces strict code quality standards:

• ESLint: JavaScript linting with modern rules
• Prettier: Automatic code formatting
• Stylelint: CSS/SCSS linting and formatting

# Start development server with hot-reloading
npm run dev

# Build for production (includes linting and formatting)
npm run build

# Code quality checks
npm run lint           # Run all linters
npm run lint:fix       # Fix linting issues automatically
npm run format         # Format code with Prettier

# Version management
npm run version:update # Update version headers
npm run version:check  # Check current version info

Enable debug logging for development:

1. Open script settings (Tampermonkey icon → WTR-Lab Novel Reviewer → Open Settings)
2. Check "Enable Debug Logging"
3. View detailed logs in browser console (F12 → Console)

The project uses a multi-target webpack configuration:

// Optimized for production with maximum performance
mode: "production",
optimization: {
  minimize: true,
  usedExports: true,
  concatenateModule: true
}

// Compliant with GreasyFork guidelines
minimize: false,  // Readable source code
headers: {
  // No updateURL/downloadURL for GreasyFork compliance
}

// Development with hot-reloading
mode: "development",
devServer: {
  port: 8080,
  hot: true,
  liveReload: false
}

dist/
├── wtr-lab-novel-reviewer.user.js          # Production build
├── wtr-lab-novel-reviewer.greasyfork.user.js  # GreasyFork build
└── wtr-lab-novel-reviewer.dev.user.js      # Development build

Automated version synchronization across:

• package.json: Source of truth for version
• Script headers: Auto-updated during build
• Build artifacts: Consistent versioning

wtr-lab-novel-reviewer/
├── .github/                    # GitHub workflows and templates
├── config/                     # Build and version configuration
│   └── versions.js            # Centralized version management
├── scripts/                    # Build and utility scripts
│   └── update-versions.js     # Version synchronization
├── src/                       # Modular source code (24 files across 8 directories)
│   ├── index.js               # Main entry point with userscript headers
│   ├── main.js                # Initialization orchestration
│   ├── config/                # Configuration management (3 files)
│   │   ├── index.js
│   │   ├── settings.js
│   │   └── constants.js
│   ├── core/                  # Core services (3 files)
│   │   ├── index.js
│   │   ├── cache.js
│   │   └── mapping.js
│   ├── api/                   # External API integration (4 files)
│   │   ├── index.js
│   │   ├── gemini.js
│   │   ├── reviews.js
│   │   └── utils.js
│   ├── assessment/            # Assessment processing (4 files)
│   │   ├── index.js
│   │   ├── classifier.js
│   │   ├── processor.js
│   │   └── schema.js
│   ├── ui/                    # User interface components (7 files)
│   │   ├── index.js
│   │   ├── components/
│   │   │   ├── index.js
│   │   │   ├── panels.js
│   │   │   ├── buttons.js
│   │   │   └── cards.js
│   │   └── styles/
│   │       ├── index.js
│   │       └── main.css
│   ├── processing/            # Batch processing orchestration (3 files)
│   │   ├── index.js
│   │   ├── batch.js
│   │   └── workflow.js
│   └── utils/                 # Utility functions (5 files)
│       ├── index.js
│       ├── colors.js
│       ├── dom.js
│       ├── delay.js
│       ├── debug.js
│       ├── router.js          # Route change detection and reactive handling
│       └── string.js          # String utility functions
├── dist/                      # Build output
├── docs/                      # Documentation
├── .prettierrc.json          # Code formatting rules
├── .stylelintrc.json         # CSS linting rules
├── eslint.config.js          # JavaScript linting rules
├── webpack.config.js         # Build configuration
├── package.json              # Dependencies and scripts
├── CHANGELOG.md              # Version history
├── LICENSE                   # MIT license
├── GreasyForkREADME.md       # User-focused documentation
└── README.md                 # This file

// Main entry points:
- src/index.js: Main entry point with userscript headers and initialization
- src/main.js: Initialization orchestration

// Core modules (24 files total):
- config/: Configuration management and settings
- core/: Core services (cache.js, mapping.js)
- api/: External API integration (gemini.js, reviews.js)
- assessment/: Assessment processing and classification
- ui/: User interface components and styling
- processing/: Batch processing and workflow orchestration
- utils/: Utility functions and helper methods

// Key functionality preserved:
- Serie ID mapping and validation
- Gemini AI integration
- Review fetching and pagination
- UI manipulation and styling
- Caching and storage management
- Error handling and retry logic
- Reactive route handling and navigation detection
- Multi-route support for "For You" and "Novel Finder" pages

• webpack.config.js: Multi-target webpack configuration
• config/versions.js: Centralized version management
• scripts/update-versions.js: Automated version updates

The WTR-Lab Novel Reviewer v1.8.4 represents a significant architectural improvement through modularization, transforming a 1,325-line monolithic file into a maintainable 24-file modular structure.

• Config: Centralized configuration management
• Core: Fundamental services (caching, mapping, validation)
• API: External service integration (Gemini, WTR-Lab)
• Assessment: Business logic and data processing
• UI: User interface components and styling
• Processing: Workflow orchestration and batch processing
• Utils: Reusable utility functions

• Isolated Development: Each module can be developed independently
• Easier Testing: Components can be tested in isolation
• Clear Dependencies: Explicit import/export relationships
• Reduced Complexity: Smaller, focused files instead of monolithic structure

• Clear Module Boundaries: Well-defined responsibilities for each module
• Barrel Exports: Clean import patterns with index.js files
• Type Safety: Better IDE support and error detection
• Documentation: Each module has clear purpose and interfaces

• Tree Shaking: Unused code automatically removed
• Code Splitting: Vendor and application code separated
• Multiple Targets: Optimized builds for different deployment scenarios
• Hot Reloading: Development server with live updates

// Before: Global scope pollution
let GEMINI_API_KEY = ''
let BATCH_LIMIT = 5

// After: Clean module boundaries
// config/constants.js
export const GEMINI_MODELS = ['gemini-2.5-flash', ...]
export const DEFAULT_BATCH_LIMIT = 5

• Module-Level Validation: Each module validates its inputs
• Graceful Degradation: Failures in one module don't crash entire system
• Enhanced Debugging: Clear error attribution to specific modules

• Lazy Loading: Modules loaded on-demand when possible
• Bundle Optimization: Webpack removes unused code automatically
• Caching Improvements: Better cache key management and validation

1. Development Testing: Use npm run dev for hot-reload testing
2. Production Testing: Install built script from dist/ folder
3. Cross-Browser Testing: Test in Chrome, Firefox, Safari, Edge

// Enable detailed logging
DEBUG_LOGGING_ENABLED = true;

// View debug output in console
console.log('[WTR-Lab Novel Reviewer Debug]', message, data);

• API Key Validation: Test with valid/invalid API keys
• Single Novel Processing: Test individual novel analysis workflow
• Error Recovery: Test network failures and API rate limits
• Caching: Test cache persistence across sessions
• Mapping Validation: Test serie ID mapping edge cases
• Cache Management: Test cache clearing functionality

Symptoms: Analysis fails with error messages Solutions:

1. Verify API key validity in Google AI Studio
2. Check network connectivity
3. Enable debug logging for detailed error information
4. Try refreshing the page and analyzing again
5. Ensure you're on supported pages (For You or Novel Finder)

Symptoms: Mapping validation fails Solutions:

1. Refresh the WTR-Lab page to retry mapping
2. Clear browser cache and reload
3. Ensure script is enabled in userscript manager

Symptoms: Outdated or corrupted analysis data Solutions:

1. Use "Clear Analyzed Novel Cache" button in settings
2. Confirm cache clearing in the prompt dialog
3. Page will automatically reload after successful clearing
4. Re-analyze novels to get fresh assessments

Symptoms: Slow analysis or high API usage Solutions:

1. Use gemini-2.5-flash model for faster processing
2. Clear cache periodically to prevent data buildup
3. Check browser console for debug information
4. Route whitelisting prevents unnecessary API calls on unsupported pages
5. Debouncing reduces redundant calls during navigation (500ms delay)
6. Route whitelisting prevents unnecessary API calls on unsupported pages
7. Debouncing reduces redundant calls during navigation (500ms delay)

Enable debug logging to access:

• API request/response details
• Processing status updates
• Performance metrics
• Error stack traces
• Cache management operations

We welcome contributions! Please follow these guidelines:

git clone https://github.com/your-username/wtr-lab-novel-reviewer.git
cd wtr-lab-novel-reviewer

git checkout -b feature/your-feature-name

# Install dependencies
npm install

# Start development
npm run dev

# Run quality checks
npm run lint
npm run format

# Build and test
npm run build

• Ensure all tests pass
• Follow code style guidelines
• Update documentation as needed
• Provide clear PR description

• Use ES6+ features
• Follow ESLint configuration
• Prefer const/let over var
• Use async/await for asynchronous code

• Follow Stylelint configuration
• Use CSS custom properties where appropriate
• Maintain accessibility standards

type(scope): brief description

Longer description if needed

Fixes #issue-number

Types: feat, fix, docs, style, refactor, test, chore

When reporting bugs, include:

• Browser and userscript manager version
• Console error messages
• Steps to reproduce
• Settings configuration
• Network conditions

• Check existing issues first
• Provide clear use case
• Consider implementation complexity
• Discuss in GitHub Discussions

// Robust mapping validation with reactive support
async function validateAndBuildSerieIdMap() {
  // Validates and builds mapping from __NEXT_DATA__
  // Implements retry logic with exponential backoff
  // Provides user feedback on mapping failures
  // Supports dynamic mapping updates on route changes
}

// Dynamic mapping update for new routes
async function updateMappingFromFetch() {
  // Fetches Next.js JSON data for new routes
  // Updates mapping for novel-finder pages
  // Maintains consistency across navigation
}

// Structured API request with error handling
const requestData = {
  contents: [{parts: [{text: prompt}]}],
  generationConfig: {
    responseMimeType: 'application/json',
    responseJsonSchema: schema,
    temperature: 0.3
  },
  safetySettings: safetySettings
};

// Intelligent pagination optimization
async function fetchReviews(serieId) {
  // Starts with Page 0 only
  // Fetches additional pages only when insufficient data
  // 60-80% reduction in unnecessary API calls
}

// Local storage-based caching with management
function getCachedAssessment(serieId) {
  // Validates cached data structure
  // Prevents corrupted cache usage
  // Automatic cleanup on errors
}

function clearAllCachedAssessments() {
  // Clears only geminiAssessment_* prefixed keys
  // Provides user confirmation
  // Offers visual feedback
}

WTR-Lab Page Load → Serie ID Mapping → Novel Card Detection →
Cache Check → Review Fetching → Gemini Analysis → UI Update →
Result Caching

1. Validation: Strict input validation at each step
2. Retry Logic: Exponential backoff for transient failures
3. User Feedback: Clear error messages and recovery instructions
4. Graceful Degradation: Partial functionality when possible
5. Cache Management: User-controlled cache operations with confirmation

const schema = {
  type: 'array',
  items: {
    type: 'object',
    properties: {
      novelSummary: {type: 'string'},
      reviewSummary: {type: 'string'},
      assessment: {enum: ['Good', 'Mixed', 'Bad']},
      characterDevelopment: {enum: ['Good', 'Mixed', 'Bad', 'Unknown']},
      plotStructure: {enum: ['Good', 'Mixed', 'Bad', 'Unknown']},
      worldBuilding: {enum: ['Good', 'Mixed', 'Bad', 'Unknown']},
      themesAndMessages: {enum: ['Good', 'Mixed', 'Bad', 'Unknown']},
      writingStyle: {enum: ['Good', 'Mixed', 'Bad', 'Unknown']}
    }
  }
};

const safetySettings = [
  {category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_NONE'},
  {category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE'},
  {category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_NONE'},
  {category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_NONE'}
];

// Optimized review fetching strategy
const url = `https://wtr-lab.com/api/review/get?serie_id=${serieId}&page=${page}&sort=most_liked`;

// Smart pagination:
// 1. Fetch Page 0 first
// 2. Check for sufficient data (≥3 reviews with comments)
// 3. Fetch additional pages only if needed
// 4. Limit to 5 pages maximum

// Extract from Next.js data
const nextDataScript = document.querySelector('script[id="__NEXT_DATA__"]');
const nextData = JSON.parse(nextDataScript.textContent);

// Build mapping for API calls
nextData.props.pageProps.list.forEach(item => {
  if (item.raw_id && item.serie_id) {
    serieIdMap.set(item.raw_id.toString(), item.serie_id.toString());
  }
});

• Page 0 First: Always fetch the most recent reviews
• Data Sufficiency Check: Only fetch additional pages if < 3 reviews with comments
• Maximum Limit: Cap at 5 pages (50 reviews) to prevent excessive API usage
• 60-80% Reduction: Significant decrease in unnecessary API calls

// Caching key structure
const cacheKey = `geminiAssessment_${serieId}`;

// Cached data validation
if (parsed && typeof parsed === 'object' && parsed.assessment) {
  return parsed;
}

• Selective Clearing: Only targets analysis cache, not general site cache
• User Control: Confirmation prompts prevent accidental data loss
• Performance Benefits: Reduces redundant API calls for re-analysis

• Efficient DOM Manipulation: Minimize reflows and repaints
• Event Delegation: Single event listeners for dynamic content
• Cleanup: Remove event listeners and observers when appropriate

• Tree Shaking: Remove unused code with webpack
• Code Splitting: Separate vendor and application code
• Minification: Compress JavaScript and CSS for production
• CSS Modularization: Component-based CSS architecture (v1.8.3+)

• Client-Side Storage: API keys stored in browser's local storage
• No Transmission: Keys never transmitted to servers other than Google
• User Control: Users maintain full control over their API keys

// Strict validation before API calls
function validateSerieIdMapping(rawId, serieId) {
  if (!serieId || serieId === null || serieId === undefined) {
    return false;
  }
  if (!/^\d+$/.test(serieId.toString())) {
    return false;
  }
  return true;
}

• Graceful Degradation: Script continues functioning despite individual failures
• No Sensitive Data Exposure: Error messages don't leak sensitive information
• Rate Limiting: Built-in delays prevent API abuse

• Minimal Permissions: Only requests necessary permissions
• External Domains: Only connects to required APIs (generativelanguage.googleapis.com)
• Sandboxed Execution: Runs in userscript environment with limited privileges
• Enhanced Matching: Explicit URL pattern matching for paginated pages (v1.8.4+)

All notable changes to this project are documented in CHANGELOG.md.

• 🚀 Reactive Execution: Implemented reactive script execution for client-side route changes in Next.js SPA environment
• 🛣️ Novel Finder Support: Extended full support to https://wtr-lab.com/en/novel-finder* pages with dedicated card parser
• 🔄 Route Handling: Added robust route change detection with debouncing (500ms) to prevent race conditions
• 🛡️ Route Whitelisting: Implemented scope restrictions to prevent processing on unsupported pages
• 🐛 Bug Fixes: Resolved route leakage issues and fixed critical serie_id mapping bug on novel-finder pages

• 🚀 Page Support: Extended web scraping capabilities to support https://wtr-lab.com/en/novel-finder* URL pattern
• 🏗️ Parser Integration: Implemented new card parser for novel-finder page's unique HTML structure
• 🐛 Critical Fix: Corrected wrong serie_id usage ensuring accurate review data for novel-finder analysis
• 🔧 Build Fix: Resolved multiple linting errors that were causing build failures

• 🚀 Cache Management: Implemented dedicated cache clearing functionality with user confirmation
• 🔄 UI Consolidation: Removed floating analysis button and centralized functionality in card-level triggers
• 🏗️ Interface Modernization: Complete UI/UX modernization with responsive design improvements
• 🐛 Bug Fixes: Resolved pagination matching issues and positioning problems
• 📱 Mobile Enhancement: Added modal overlay behavior for AI Summary Panel on mobile devices
• 🎨 Design System: Applied Flexbox-based solutions and modern design patterns

• 🏗️ CSS Modularization: Complete modularization of 1,325-line monolithic CSS into component-based structure
• ❌ Cleanup: Eliminated duplicate CSS and dynamic style injection
• 🔄 Build System: Switched to webpack's CSS processing for better optimization

• ❌ Batch Processing: Removed configurable batch processing, now processes 1 novel at a time
• 🏗️ Architecture: Streamlined processing architecture for better control

• 🏗️ Complete Modularization: Transform from 1,325-line file to maintainable 24-file architecture
• 📁 Code Organization: Clear separation of concerns across 8 modular directories
• 🔧 Build System: Enhanced validation and error resolution
• 🚀 Deployment: Optimized for three deployment targets (Performance, GreasyFork, Development)

• ✨ Color-coded review summary system with username attribution
• 🎨 20-color accessible palette for consistent user identification
• 📊 Enhanced assessment categories with "Unknown" ratings
• 🚀 Optimized review fetching with smart pagination
• 🛡️ Enhanced error handling and validation systems
• 🏷️ Standardized genre labeling system
• ⚡ Improved performance with caching and retry logic

This project is licensed under the MIT License - see the LICENSE file for details.

MIT License

Copyright (c) 2025 MasuRii Math Lee マス リ

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

• Google Gemini AI: Powering the novel analysis capabilities
• Webpack: Modern build system and optimization
• ESLint & Prettier: Code quality and formatting standards
• Stylelint: CSS linting and best practices

• WTR-Lab: Providing the novel platform and API access
• GreasyFork: Hosting and distribution platform
• Userscript Community: Best practices and inspiration

• Tampermonkey: Userscript management and execution
• GitHub: Version control and collaboration platform
• Node.js & npm: Development environment and dependencies

• GitHub Issues: Report bugs or request features
• Include: Browser version, userscript manager, console logs, reproduction steps

• GitHub Discussions: Community support and Q&A
• Documentation: This README and inline code comments

• GreasyFork: User reviews and feedback

• Contributing Guidelines: See Contributing Section
• Code Standards: ESLint, Prettier, and Stylelint configurations
• Build Issues: Check webpack configuration and dependency versions

Built with ❤️ for the WTR-Lab community using modern web technologies and AI-powered analysis.

For the end-user focused documentation, see GreasyForkREADME.md