cursorflow 2.0.0__tar.gz → 2.0.1__tar.gz

{cursorflow-2.0.0 → cursorflow-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cursorflow
-Version: 2.0.0
+Version: 2.0.1
 Summary: 🔥 Complete page intelligence for AI-driven development with Hot Reload Intelligence - captures DOM, network, console, performance, HMR events, and comprehensive page analysis
 Author-email: GeekWarrior Development <rbush@cooltheory.com>
 License-Expression: MIT

{cursorflow-2.0.0 → cursorflow-2.0.1}/cursorflow/rules/cursorflow-installation.mdc

@@ -1,18 +1,18 @@
 ---
-title: CursorFlow CLI Installation & Setup Guide for Cursor
-description: How to install and configure CursorFlow CLI in any project for autonomous UI testing
+title: CursorFlow 2.0.0 Installation & Setup Guide for Cursor
+description: How to install and configure CursorFlow 2.0.0 for complete page intelligence in AI-driven development
 ---
 
-# CursorFlow CLI Installation & Setup Guide for Cursor
+# CursorFlow 2.0.0 Installation & Setup Guide for Cursor
 
-## 🚀 **When to Install CursorFlow**
+## 🚀 **When to Install CursorFlow 2.0.0**
 
 ### **Automatically Install When:**
 - User mentions UI testing, visual debugging, or layout issues
 - User asks to "test this component" or "check if this works"
 - User is working on CSS/layout modifications
 - User reports frontend bugs or authentication issues
-- New project setup where UI testing would be valuable
+- New project setup where comprehensive UI analysis would be valuable
 
 ### **Project Types That Benefit:**
 - Web applications (React, Vue, Angular, PHP, Django, Rails)
@@ -20,42 +20,46 @@ description: How to install and configure CursorFlow CLI in any project for auto
 - E-commerce sites with complex user flows
 - Admin dashboards and data visualization
 - Any project with user authentication
+- Development projects using Vite, Webpack, Next.js, Parcel, Laravel Mix
 
 ## 📦 **Installation Steps**
 
-### **1. Install CursorFlow CLI:**
+### **1. Install CursorFlow 2.0.0:**
 ```bash
-# Install the universal testing CLI
+# Install CursorFlow 2.0.0 with complete page intelligence
 pip install cursorflow
 
 # Install browser automation dependencies
-cursorflow install-deps
+playwright install chromium
 
-# Verify installation
+# Verify installation and check v2.0.0 features
 cursorflow --version
 ```
 
 ### **2. Initialize Project:**
 ```bash
-# Initialize CursorFlow in the project (creates config + installs rules)
+# Initialize CursorFlow in the project (creates config + installs Cursor rules)
 cursorflow init .
 
 # This automatically:
 # - Creates cursor-test-config.json with smart defaults
-# - Sets up .cursorflow/ directory structure
-# - Configures for your web technology
+# - Sets up .cursorflow/ directory structure  
+# - Configures for your web technology stack
+# - Installs Cursor AI rules for autonomous operation
 ```
 
-### **3. Verify Installation:**
+### **3. Verify v2.0.0 Installation:**
 ```bash
-# Test basic functionality
+# Test comprehensive data capture
 cursorflow test --base-url http://localhost:3000 --path "/"
 
 # Check configuration
 cat cursor-test-config.json
 
-# Verify artifacts directory
-ls -la .cursorflow/
+# Verify artifacts directory structure
+ls -la .cursorflow/artifacts/
+ls -la .cursorflow/artifacts/diagnostics/
+ls -la .cursorflow/artifacts/traces/
 ```
 
 ## ⚙️ **Auto-Generated Configuration**
@@ -87,41 +91,58 @@ CursorFlow creates smart defaults based on your project:
 }
 ```
 
-## 🎯 **Quick Start Examples**
+## 🎯 **CursorFlow 2.0.0 Quick Start Examples**
 
-### **Test a Component:**
+### **Test UI Component with Complete Intelligence:**
 ```bash
-# Test any UI component
-cursorflow test dashboard --base-url http://localhost:3000
-
-# Results in structured JSON + artifacts:
-# - Browser interaction timeline
-# - Screenshots in .cursorflow/artifacts/
-# - Console logs and server logs
-# - Network requests and responses
+# Test any UI component with comprehensive data capture
+cursorflow test --base-url http://localhost:3000 --path "/dashboard"
+
+# Results include:
+# - 🔥 Hot Reload Intelligence (framework auto-detection)
+# - 🧠 Advanced Element Intelligence (7 selector strategies)
+# - 📊 Comprehensive Page Analysis (fonts, animations, resources, storage)
+# - 🎯 Enhanced Error Context (smart screenshot deduplication)
+# - ⚡ Enhanced Browser Data (Playwright traces, network intelligence)
 ```
 
-### **Debug Authentication:**
+### **Debug Authentication with Rich Context:**
 ```bash
-# Test login flow
-cursorflow test login-form --base-url http://localhost:3000
-
-# Analyze output for:
-# - Authentication errors in timeline
-# - Session state issues
-# - Server response patterns
+# Test login flow with comprehensive error context
+cursorflow test \
+  --base-url http://localhost:3000 \
+  --actions '[
+    {"navigate": "/login"},
+    {"fill": {"selector": "#username", "value": "test@example.com"}},
+    {"fill": {"selector": "#password", "value": "testpass"}},
+    {"click": "#login-button"},
+    {"wait_for": ".dashboard, .error-message"},
+    {"screenshot": "login-result"}
+  ]'
+
+# Analyze comprehensive output for:
+# - Authentication errors with full context
+# - Network request/response details
+# - Console error correlation
+# - Element interaction intelligence
 ```
 
-### **CSS Iteration:**
+### **CSS Development with HMR Intelligence:**
 ```bash
-# Before: Test current state
-cursorflow test dashboard --base-url http://localhost:3000
+# Before: Test current state with framework detection
+cursorflow test --base-url http://localhost:3000 --path "/component"
 
 # Apply CSS changes to actual files
-# After: Test improved state  
-cursorflow test dashboard --base-url http://localhost:3000
+# CursorFlow automatically detects your framework (Vite, Webpack, Next.js, etc.)
 
-# Compare screenshots in .cursorflow/artifacts/
+# After: Test improved state with HMR correlation
+cursorflow test --base-url http://localhost:3000 --path "/component"
+
+# Compare comprehensive data:
+# - Screenshots in .cursorflow/artifacts/screenshots/
+# - HMR event correlation in results JSON
+# - Performance impact analysis
+# - Element intelligence changes
 ```
 
 ## 🌍 **Environment-Specific Setup**
@@ -285,13 +306,38 @@ cursorflow --help        # View all commands
 - Test artifacts are created and organized properly
 - Cursor can use `cursorflow test` for any component
 
-## 🌟 **Result: Cursor Superpowers Activated!**
-
-Once installed, Cursor can autonomously:
-- Test any UI component with simple CLI commands
-- Collect comprehensive browser and server data
-- Analyze results and make informed decisions
-- Iterate on designs with visual feedback
-- Debug issues with complete visibility
-
-**Installation complete = Development superpowers activated!** 🚀
+## 🌟 **Result: Cursor AI Superpowers Activated with v2.0.0!**
+
+Once installed, Cursor can autonomously leverage complete page intelligence:
+
+### **🔥 Hot Reload Intelligence:**
+- Auto-detect development frameworks (Vite, Webpack, Next.js, Parcel, Laravel Mix)
+- Monitor WebSocket connections for HMR events
+- Correlate CSS changes with visual updates
+- Optimize testing timing with framework-specific intelligence
+
+### **🧠 Advanced Element Intelligence:**
+- Utilize 7 selector strategies for robust element targeting
+- Access comprehensive accessibility analysis
+- Leverage visual context data for interaction decisions
+- Apply computed style intelligence for CSS debugging
+
+### **📊 Comprehensive Page Analysis:**
+- Monitor font loading status and performance
+- Track animation states and transitions
+- Analyze resource loading patterns and optimization opportunities
+- Inspect storage state (localStorage, sessionStorage, cookies)
+
+### **🎯 Enhanced Error Context Collection:**
+- Automatic error detection with rich diagnostic data
+- Smart screenshot deduplication to avoid redundancy
+- Comprehensive error correlation across browser and network layers
+- Diagnostic artifacts organized for AI analysis
+
+### **⚡ Enhanced Browser Data Capture:**
+- Full Playwright trace recording for complex debugging
+- Network request/response intelligence with performance data
+- Console message correlation with interaction timeline
+- Performance metrics and optimization insights
+
+**CursorFlow 2.0.0 Installation Complete = AI-Driven Development Superpowers Activated!** 🚀

{cursorflow-2.0.0 → cursorflow-2.0.1}/cursorflow/rules/cursorflow-usage.mdc

@@ -1,99 +1,230 @@
 # CursorFlow Usage Rules for Cursor AI
 
-## 🔥 **PRIMARY USE CASE: Hot Reload CSS Iteration**
+## 🔥 **CursorFlow 2.0.0: Complete Page Intelligence for AI-Driven Development**
 
-**ALWAYS USE `css_iteration_persistent()` for CSS/UI work** - this is CursorFlow's core strength:
+**CursorFlow provides comprehensive data collection for rapid UI iteration:**
 
-- 🚀 **3-5x faster** than normal testing with hot reload integration
-- 🎯 **Preserves application state** during CSS iterations  
-- 🔥 **Automatic hot reload detection** (Webpack HMR, Vite, Next.js, etc.)
-- ⚡ **Instant visual feedback** without page reloads
-- 🧠 **Intelligent session management** with automatic cleanup
+- 🔥 **Hot Reload Intelligence** - Auto-detects Vite, Webpack, Next.js, Parcel, Laravel Mix
+- 🧠 **Advanced Element Intelligence** - 7 selector strategies + accessibility analysis
+- 📊 **Comprehensive Page Analysis** - Fonts, animations, resources, storage state
+- 🎯 **Enhanced Error Context Collection** - Smart screenshot deduplication
+- ⚡ **Enhanced Browser Data Capture** - Playwright traces + network interception
 
 ## When to Use CursorFlow
 
-### **CSS/UI Development (PRIORITY 1 - Use Persistent Sessions)**
+### **UI Testing & Development (PRIMARY USE CASE)**
 - CSS styling, layout adjustments, responsive design
 - Visual hierarchy improvements, spacing, typography
 - Component styling and design system work
 - UI bug fixes and visual improvements
 - Design iteration and rapid prototyping
-
-### **UI Testing & Debugging (Use CLI)**
 - Form submissions and user interactions  
 - Authentication flows and session handling
 - Frontend-backend interaction problems
 - Error reproduction and debugging
 - Cross-browser compatibility testing
 
-## 🔥 **Hot Reload CSS Iteration (PRIMARY METHOD)**
+## 🔥 **Hot Reload Intelligence (v2.0.0)**
+
+CursorFlow auto-detects and integrates with development frameworks:
 
-### **Ultra-Fast CSS Iteration Pattern**
+### **Supported Frameworks:**
+- **Vite** (port 5173, WebSocket `/__vite_hmr`)
+- **Webpack Dev Server** (port 3000, WebSocket `/sockjs-node`)
+- **Next.js** (port 3000, WebSocket `/_next/webpack-hmr`)
+- **Parcel** (port 1234, WebSocket `/hmr`)
+- **Laravel Mix** (port 3000, WebSocket `/browser-sync/socket.io`)
+
+### **Hot Reload Usage Pattern:**
 ```python
 from cursorflow import CursorFlow
 
-# Initialize with hot reload support
+# Initialize with HMR auto-detection
 flow = CursorFlow(
     base_url="http://localhost:3000",  # Your dev server
     log_config={"source": "local", "paths": ["logs/app.log"]},
-    browser_config={"hot_reload_enabled": True, "keep_alive": True}
+    browser_config={"headless": True}
 )
 
-# CSS changes to test rapidly
-css_changes = [
-    {
-        "name": "improve-spacing", 
-        "css": ".container { gap: 2rem; padding: 1.5rem; }",
-        "rationale": "Better visual hierarchy"
-    },
-    {
-        "name": "add-shadows",
-        "css": ".card { box-shadow: 0 4px 6px rgba(0,0,0,0.1); }",
-        "rationale": "Add depth and visual interest"
-    }
-]
-
-# Execute with persistent session - 3-5x faster!
-results = await flow.css_iteration_persistent(
-    base_actions=[{"navigate": "/dashboard"}, {"wait_for": "#main-content"}],
-    css_changes=css_changes,
-    session_options={"hot_reload": True, "keep_session_alive": True}
+# CursorFlow automatically:
+# 1. Detects your framework (Vite, Webpack, Next.js, etc.)
+# 2. Monitors WebSocket for HMR events
+# 3. Waits for CSS updates instead of arbitrary delays
+# 4. Captures precise timing of hot reload events
+
+# Execute test with HMR intelligence
+results = await flow.execute_and_collect(
+    actions=[
+        {"navigate": "/dashboard"},
+        {"wait_for": "body"},
+        {"screenshot": "initial"}
+    ]
 )
 
-# Analyze results
-print(f"🔥 Hot reload used: {results.get('hot_reload_used')}")
-print(f"⚡ Iterations/min: {results.get('persistent_analysis', {}).get('iteration_speed_metrics', {}).get('iterations_per_minute', 0):.1f}")
+# HMR status available in results
+hmr_status = results.get('hmr_status', {})
+print(f"Framework detected: {hmr_status.get('detected_framework', 'None')}")
 ```
 
-### **Session Continuation (No Page Reload!)**
+## 🧠 **Advanced Element Intelligence (v2.0.0)**
+
+Every screenshot captures comprehensive element data:
+
+### **7 Selector Strategies:**
+- **CSS Selectors**: `#id`, `.class`, `tag[attr]`
+- **XPath**: `//div[@class='container']`
+- **Text-based**: Elements containing specific text
+- **Role-based**: `[role='button']`, `[role='navigation']`
+- **Test ID**: `[data-testid='submit-button']`
+- **ARIA Labels**: `[aria-label='Close dialog']`
+- **Unique CSS**: Auto-generated unique selectors
+
+### **Comprehensive Element Data:**
 ```python
-# First iteration - sets up persistent session
-results1 = await flow.css_iteration_persistent(
-    base_actions=[{"navigate": "/page"}],
-    css_changes=[{"name": "initial", "css": ".container { display: flex; }"}],
-    session_options={"session_id": "my_session", "keep_session_alive": True}
-)
+# Every screenshot includes detailed element analysis
+results = await flow.execute_and_collect([
+    {"navigate": "/dashboard"},
+    {"screenshot": "dashboard"}
+])
+
+# Access rich element data
+screenshot_data = results['artifacts']['screenshots'][0]
+elements = screenshot_data['dom_analysis']['elements']
+
+for element in elements:
+    print(f"Tag: {element['tagName']}")
+    print(f"Unique Selector: {element['uniqueSelector']}")
+    print(f"Accessibility Role: {element['accessibility']['role']}")
+    print(f"Is Interactive: {element['accessibility']['isInteractive']}")
+    print(f"Bounding Box: {element['boundingBox']}")
+    print(f"Computed Styles: {element['computedStyles']}")
+    print(f"Visual Context: {element['visual_context']}")
+```
 
-# Continue with same session - INSTANT feedback!
-results2 = await flow.css_iteration_persistent(
-    base_actions=[],  # No base actions needed - session preserved!
-    css_changes=[{"name": "refine", "css": ".container { gap: 1rem; }"}],
-    session_options={"session_id": "my_session", "reuse_session": True}
-)
+## 📊 **Comprehensive Page Analysis (v2.0.0)**
+
+Every screenshot captures complete page intelligence:
+
+### **Font Loading Analysis:**
+- Total fonts loaded/loading/failed
+- Font family details and loading metrics
+- Used font families on the page
+
+### **Animation State Tracking:**
+- Running/paused/finished animations
+- CSS transitions and their states
+- Performance impact analysis
+
+### **Resource Loading Intelligence:**
+- Total resources by type (JS, CSS, images)
+- Loading performance metrics
+- Critical resource identification
+- Cache hit rates and compression ratios
+
+### **Storage State Analysis:**
+- localStorage and sessionStorage contents
+- Cookie count and sizes
+- IndexedDB availability
+
+### **Usage Example:**
+```python
+results = await flow.execute_and_collect([
+    {"navigate": "/app"},
+    {"screenshot": "comprehensive"}
+])
+
+screenshot_data = results['artifacts']['screenshots'][0]
+
+# Access comprehensive analysis
+print(f"Fonts loaded: {screenshot_data['font_status']['total_loaded_fonts']}")
+print(f"Animations running: {screenshot_data['animation_status']['total_running_animations']}")
+print(f"Resources loaded: {screenshot_data['resource_status']['total_resources']}")
+print(f"Storage items: {screenshot_data['storage_state']['localStorage']['item_count']}")
 ```
 
-### **Hot Reload Decision Framework**
-1. **User mentions CSS/styling** → Use `css_iteration_persistent()`
-2. **User wants UI improvements** → Use persistent sessions  
-3. **User asks to "test this component"** → Use hot reload iteration
-4. **User reports layout issues** → Use CSS iteration with screenshots
-5. **User wants responsive testing** → Use persistent sessions with viewport changes
+## 🎯 **Enhanced Error Context Collection (v2.0.0)**
 
-## Basic CursorFlow CLI Usage
+CursorFlow automatically captures rich error context with smart deduplication:
 
-### Simple Tests
+### **Automatic Error Detection:**
+- Console errors and warnings
+- Network request failures (4xx, 5xx responses)
+- JavaScript exceptions and unhandled promises
+- Page crashes and navigation failures
+
+### **Smart Screenshot Deduplication:**
+- Reuses screenshots when page content hasn't changed
+- Avoids duplicate captures for multiple errors in close proximity
+- Maintains comprehensive diagnostic coverage
+
+### **Comprehensive Error Context:**
+```python
+# Errors are automatically detected and context collected
+results = await flow.execute_and_collect([
+    {"navigate": "/page"},
+    {"click": "#nonexistent-button"}  # This will trigger error collection
+])
+
+# Access error context summary
+error_summary = flow.get_error_context_summary()
+print(f"Total errors: {error_summary['total_errors_collected']}")
+print(f"Error types: {error_summary['unique_error_types']}")
+print(f"Screenshot dedup rate: {error_summary['screenshot_deduplication_rate']}")
+
+# Diagnostic screenshots saved to: .cursorflow/artifacts/diagnostics/
+```
+
+## ⚡ **Enhanced Browser Data Capture (v2.0.0)**
+
+Every screenshot includes comprehensive browser intelligence:
+
+### **Playwright Trace Integration:**
+- Full interaction traces for debugging
+- Network request/response details
+- Performance timeline data
+- Console message correlation
+
+### **Network Intelligence:**
+- Request/response headers and bodies
+- Performance timing data
+- Failed request analysis
+- Resource loading optimization insights
+
+### **Console Intelligence:**
+- JavaScript errors with stack traces
+- Application logs and debug messages
+- Performance warnings
+- Framework-specific messages
+
+### **Usage Example:**
+```python
+# Start session with trace recording
+results = await flow.execute_and_collect(
+    actions=[
+        {"navigate": "/app"},
+        {"click": "#submit-form"},
+        {"screenshot": "result"}
+    ],
+    session_options={'start_trace': True}
+)
+
+# Access comprehensive data
+screenshot_data = results['artifacts']['screenshots'][0]
+print(f"Network requests: {len(screenshot_data['network_data']['requests'])}")
+print(f"Console messages: {len(screenshot_data['console_data']['messages'])}")
+print(f"Performance metrics: {screenshot_data['performance_data']}")
+
+# Playwright trace available at: .cursorflow/artifacts/traces/session.zip
+```
+
+## 🚀 **CursorFlow CLI Usage (v2.0.0)**
+
+### **Basic Testing:**
 ```bash
-# Test with inline actions
+# Test any URL with comprehensive data capture
+cursorflow test --base-url http://localhost:3000 --path "/dashboard"
+
+# Test with custom actions
 cursorflow test \
   --base-url http://localhost:3000 \
   --actions '[
@@ -102,26 +233,22 @@ cursorflow test \
     {"screenshot": "state"}
   ]'
 
-# Simple path test
-cursorflow test --base-url http://localhost:3000 --path "/dashboard"
+# Results include:
+# - Hot Reload Intelligence status
+# - Advanced Element Intelligence (7 selector types)
+# - Comprehensive Page Analysis (fonts, animations, resources)
+# - Enhanced Error Context (smart deduplication)
+# - Enhanced Browser Data (Playwright traces)
 ```
 
-### Complex Tests
+### **Available CLI Commands:**
 ```bash
-# Create action file first
-cat > test-actions.json << 'EOF'
-[
-  {"navigate": "/login"},
-  {"fill": {"selector": "#username", "value": "test@example.com"}},
-  {"fill": {"selector": "#password", "value": "testpass"}},
-  {"click": "#login-button"},
-  {"wait_for": ".dashboard"},
-  {"screenshot": "logged-in"}
-]
-EOF
-
-# Run test
-cursorflow test --base-url http://localhost:3000 --actions test-actions.json
+cursorflow test              # Execute comprehensive UI test
+cursorflow compare-mockup    # Visual mockup comparison
+cursorflow iterate-mockup    # Iterative mockup matching
+cursorflow install-rules     # Install Cursor AI rules
+cursorflow update           # Update CursorFlow and dependencies
+cursorflow --help           # Show all commands and options
 ```
 
 ## Available Actions
@@ -400,24 +527,33 @@ cursorflow install-rules
 cursorflow update
 ```
 
-## 🎯 **CRITICAL REMINDERS FOR CURSOR AI**
+## 🎯 **CRITICAL REMINDERS FOR CURSOR AI (v2.0.0)**
 
-### **🔥 PRIMARY WORKFLOW: Hot Reload CSS Iteration**
-- **ALWAYS use `css_iteration_persistent()` for CSS/UI work** 
-- **3-5x faster than CLI** - enables rapid design exploration
-- **Preserves application state** - no lost context during iteration
-- **Auto-detects hot reload** - works with Webpack, Vite, Next.js, etc.
+### **🔥 PRIMARY WORKFLOW: Comprehensive Data Collection**
+- **ALWAYS use CursorFlow for UI testing and debugging** 
+- **Every screenshot captures complete page intelligence**
+- **Automatic framework detection and HMR integration**
+- **Smart error context collection with deduplication**
 
 ### **Decision Framework:**
-- **User mentions CSS/styling/layout** → `css_iteration_persistent()`
-- **User wants UI improvements** → Persistent sessions with hot reload
-- **User asks to "test component"** → Hot reload CSS iteration
-- **User reports form/auth issues** → Traditional CLI testing
+- **User mentions UI/CSS/layout** → Use CursorFlow CLI or Python API
+- **User wants to test component** → Use comprehensive data capture
+- **User reports errors/bugs** → Leverage enhanced error context
+- **User needs element analysis** → Utilize 7 selector strategies
+- **User works with dev server** → Benefit from HMR intelligence
 
 ### **Key Success Patterns:**
-1. **Start persistent session** → Test multiple CSS approaches → Continue session → Apply best result
-2. **Monitor `hot_reload_used`** → Expect 12+ iterations per minute when working
-3. **Use session continuation** → Avoid page reloads → Maintain complex application state
-4. **Apply recommended CSS** → Let CursorFlow identify target files → Implement changes
-
-Remember: **CursorFlow's persistent sessions with hot reload are 3-5x faster than traditional testing.** Always prioritize this workflow for CSS/UI development to maximize iteration speed and preserve application state.
+1. **Run CursorFlow test** → Analyze comprehensive data → Make informed decisions
+2. **Monitor HMR status** → Leverage framework-specific optimizations
+3. **Use element intelligence** → Select optimal interaction strategies
+4. **Review error context** → Understand root causes with rich diagnostics
+5. **Apply trace analysis** → Debug complex interaction flows
+
+### **v2.0.0 Data Available in Every Test:**
+- 🔥 **Hot Reload Intelligence**: Framework detection and HMR event monitoring
+- 🧠 **Advanced Element Intelligence**: 7 selector types + accessibility analysis
+- 📊 **Comprehensive Page Analysis**: Fonts, animations, resources, storage
+- 🎯 **Enhanced Error Context**: Smart screenshot deduplication + diagnostics
+- ⚡ **Enhanced Browser Data**: Playwright traces + network intelligence
+
+Remember: **CursorFlow 2.0.0 provides complete page intelligence for AI-driven development.** Every test captures comprehensive data to enable informed decision-making and rapid iteration.

{cursorflow-2.0.0 → cursorflow-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cursorflow"
-version = "2.0.0"
+version = "2.0.1"
 description = "🔥 Complete page intelligence for AI-driven development with Hot Reload Intelligence - captures DOM, network, console, performance, HMR events, and comprehensive page analysis"
 authors = [
     {name = "GeekWarrior Development", email = "rbush@cooltheory.com"}