cursorflow 2.6.1__tar.gz → 2.6.3__tar.gz

{cursorflow-2.6.1 → cursorflow-2.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cursorflow
-Version: 2.6.1
+Version: 2.6.3
 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.6.1 → cursorflow-2.6.3}/cursorflow/cli.py

@@ -15,6 +15,7 @@ from typing import Dict
 from rich.console import Console
 from rich.table import Table
 from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.markup import escape
 
 from .core.agent import TestAgent
 from . import __version__
@@ -185,10 +186,10 @@ def test(base_url, path, actions, output, logs, config, verbose, headless, timeo
                 test_actions = json.loads(actions)
                 console.print(f"📋 Using inline actions")
         except json.JSONDecodeError as e:
-            console.print(f"[red]❌ Invalid JSON in actions: {e}[/red]")
+            console.print(f"[red]❌ Invalid JSON in actions: {escape(str(e))}[/red]")
             return
         except Exception as e:
-            console.print(f"[red]❌ Failed to load actions: {e}[/red]")
+            console.print(f"[red]❌ Failed to load actions: {escape(str(e))}[/red]")
             return
     elif path:
         # Simple path navigation with optional wait conditions
@@ -236,7 +237,7 @@ def test(base_url, path, actions, output, logs, config, verbose, headless, timeo
             **agent_config
         )
     except Exception as e:
-        console.print(f"[red]Error initializing CursorFlow: {e}[/red]")
+        console.print(f"[red]Error initializing CursorFlow: {escape(str(e))}[/red]")
         return
     
     # Execute test actions
@@ -339,7 +340,7 @@ def test(base_url, path, actions, output, logs, config, verbose, headless, timeo
                 console.print(f"💡 View manually: playwright show-trace {trace_path}")
         
     except Exception as e:
-        console.print(f"[red]❌ Test failed: {e}[/red]")
+        console.print(f"[red]❌ Test failed: {escape(str(e))}[/red]")
         if verbose:
             import traceback
             console.print(traceback.format_exc())
@@ -398,7 +399,7 @@ def compare_mockup(mockup_url, base_url, mockup_actions, implementation_actions,
             comparison_config["viewports"] = viewports_parsed
         
     except Exception as e:
-        console.print(f"[red]Error parsing input parameters: {e}[/red]")
+        console.print(f"[red]Error parsing input parameters: {escape(str(e))}[/red]")
         return
     
     # Initialize CursorFlow
@@ -411,7 +412,7 @@ def compare_mockup(mockup_url, base_url, mockup_actions, implementation_actions,
             browser_config={'headless': True}
         )
     except Exception as e:
-        console.print(f"[red]Error initializing CursorFlow: {e}[/red]")
+        console.print(f"[red]Error initializing CursorFlow: {escape(str(e))}[/red]")
         return
     
     # Execute mockup comparison
@@ -425,7 +426,7 @@ def compare_mockup(mockup_url, base_url, mockup_actions, implementation_actions,
         ))
         
         if "error" in results:
-            console.print(f"[red]❌ Comparison failed: {results['error']}[/red]")
+            console.print(f"[red]❌ Comparison failed: {escape(str(results['error']))}[/red]")
             return
         
         # Display results summary (pure metrics only)
@@ -453,7 +454,7 @@ def compare_mockup(mockup_url, base_url, mockup_actions, implementation_actions,
         console.print(f"📁 Visual diffs stored in: [cyan].cursorflow/artifacts/[/cyan]")
         
     except Exception as e:
-        console.print(f"[red]❌ Comparison failed: {e}[/red]")
+        console.print(f"[red]❌ Comparison failed: {escape(str(e))}[/red]")
         if verbose:
             import traceback
             console.print(traceback.format_exc())
@@ -500,7 +501,7 @@ def iterate_mockup(mockup_url, base_url, css_improvements, base_actions, diff_th
         comparison_config = {"diff_threshold": diff_threshold}
         
     except Exception as e:
-        console.print(f"[red]Error parsing input parameters: {e}[/red]")
+        console.print(f"[red]Error parsing input parameters: {escape(str(e))}[/red]")
         return
     
     # Initialize CursorFlow
@@ -512,7 +513,7 @@ def iterate_mockup(mockup_url, base_url, css_improvements, base_actions, diff_th
             browser_config={'headless': True}
         )
     except Exception as e:
-        console.print(f"[red]Error initializing CursorFlow: {e}[/red]")
+        console.print(f"[red]Error initializing CursorFlow: {escape(str(e))}[/red]")
         return
     
     # Execute iterative mockup matching
@@ -526,7 +527,7 @@ def iterate_mockup(mockup_url, base_url, css_improvements, base_actions, diff_th
         ))
         
         if "error" in results:
-            console.print(f"[red]❌ Iteration failed: {results['error']}[/red]")
+            console.print(f"[red]❌ Iteration failed: {escape(str(results['error']))}[/red]")
             return
         
         # Display results summary
@@ -563,7 +564,7 @@ def iterate_mockup(mockup_url, base_url, css_improvements, base_actions, diff_th
         console.print(f"📁 Iteration progress stored in: [cyan].cursorflow/artifacts/[/cyan]")
         
     except Exception as e:
-        console.print(f"[red]❌ Iteration failed: {e}[/red]")
+        console.print(f"[red]❌ Iteration failed: {escape(str(e))}[/red]")
         if verbose:
             import traceback
             console.print(traceback.format_exc())
@@ -620,7 +621,7 @@ async def _run_auto_tests(framework: str, base_url: str, config: Dict):
         display_smoke_test_summary(results)
         
     except Exception as e:
-        console.print(f"[red]Auto-test failed: {e}[/red]")
+        console.print(f"[red]Auto-test failed: {escape(str(e))}[/red]")
 
 @main.command()
 @click.argument('project_path', default='.')
@@ -648,7 +649,7 @@ def install_rules(project_path, framework, force, yes):
             console.print("[red]❌ Installation failed[/red]")
             
     except Exception as e:
-        console.print(f"[red]Installation error: {e}[/red]")
+        console.print(f"[red]Installation error: {escape(str(e))}[/red]")
 
 @main.command()
 @click.option('--force', is_flag=True, help='Force update even if no updates available')
@@ -670,7 +671,7 @@ def update(force, project_dir):
             console.print("[red]❌ Update failed[/red]")
             
     except Exception as e:
-        console.print(f"[red]Update error: {e}[/red]")
+        console.print(f"[red]Update error: {escape(str(e))}[/red]")
 
 @main.command()
 @click.option('--project-dir', default='.', help='Project directory')
@@ -684,7 +685,7 @@ def check_updates(project_dir):
         result = asyncio.run(check_updates(project_dir))
         
         if "error" in result:
-            console.print(f"[red]Error checking updates: {result['error']}[/red]")
+            console.print(f"[red]Error checking updates: {escape(str(result['error']))}[/red]")
             return
         
         # Display update information
@@ -723,7 +724,7 @@ def check_updates(project_dir):
             console.print("\n💡 Run [bold]cursorflow update[/bold] to install updates")
         
     except Exception as e:
-        console.print(f"[red]Error: {e}[/red]")
+        console.print(f"[red]Error: {escape(str(e))}[/red]")
 
 @main.command()
 @click.option('--project-dir', default='.', help='Project directory')
@@ -744,7 +745,7 @@ def install_deps(project_dir):
             console.print("[red]❌ Dependency installation failed[/red]")
             
     except Exception as e:
-        console.print(f"[red]Error: {e}[/red]")
+        console.print(f"[red]Error: {escape(str(e))}[/red]")
 
 @main.command()
 @click.argument('subcommand', required=False)
@@ -959,7 +960,7 @@ def inspect(base_url, path, selector, verbose):
             console.print(f"\n📸 Screenshot saved: [cyan]{screenshot_path}[/cyan]")
         
     except Exception as e:
-        console.print(f"[red]❌ Inspection failed: {e}[/red]")
+        console.print(f"[red]❌ Inspection failed: {escape(str(e))}[/red]")
         import traceback
         console.print(traceback.format_exc())
 
@@ -1086,7 +1087,7 @@ def measure(base_url, path, selector, verbose):
         console.print("✅ Measurement complete")
         
     except Exception as e:
-        console.print(f"[red]❌ Measurement failed: {e}[/red]")
+        console.print(f"[red]❌ Measurement failed: {escape(str(e))}[/red]")
         import traceback
         console.print(traceback.format_exc())
 
@@ -1137,7 +1138,7 @@ def count(base_url, path, selector):
             console.print(f"💡 Total elements on page: {len(elements)}")
         
     except Exception as e:
-        console.print(f"[red]❌ Count failed: {e}[/red]")
+        console.print(f"[red]❌ Count failed: {escape(str(e))}[/red]")
         import traceback
         console.print(traceback.format_exc())
 
@@ -1174,7 +1175,7 @@ def rerun(click, hover):
         console.print("✅ Rerun completed")
         
     except Exception as e:
-        console.print(f"[red]❌ Rerun failed: {e}[/red]")
+        console.print(f"[red]❌ Rerun failed: {escape(str(e))}[/red]")
 
 @main.command()
 @click.option('--session', '-s', required=True, help='Session ID to view timeline for')
@@ -1227,7 +1228,7 @@ def timeline(session):
             console.print(f"\n... and {len(timeline) - 50} more events")
         
     except Exception as e:
-        console.print(f"[red]❌ Failed to load timeline: {e}[/red]")
+        console.print(f"[red]❌ Failed to load timeline: {escape(str(e))}[/red]")
 
 @main.command()
 @click.option('--artifacts', is_flag=True, help='Clean all artifacts (screenshots, traces)')
@@ -1337,7 +1338,7 @@ def cleanup(artifacts, sessions, old_only, clean_all, dry_run, yes):
                 item_path.unlink()
             deleted_count += 1
         except Exception as e:
-            console.print(f"[red]⚠️  Failed to delete {item_path}: {e}[/red]")
+            console.print(f"[red]⚠️  Failed to delete {item_path}: {escape(str(e))}[/red]")
     
     console.print(f"\n✅ Cleanup complete!")
     console.print(f"   • Deleted {deleted_count}/{len(items_to_delete)} items")
@@ -1418,7 +1419,7 @@ def _display_test_results(results: Dict, test_description: str, show_console: bo
         if errors:
             console.print(f"\n[red]❌ Console Errors ({len(errors)}):[/red]")
             for error in errors[:5]:  # Show first 5
-                console.print(f"   [red]{error.get('text', 'Unknown error')}[/red]")
+                console.print(f"   [red]{escape(str(error.get('text', 'Unknown error')))}[/red]")
         
         if warnings:
             console.print(f"\n[yellow]⚠️  Console Warnings ({len(warnings)}):[/yellow]")

{cursorflow-2.6.1 → cursorflow-2.6.3}/cursorflow/core/browser_controller.py

@@ -189,165 +189,205 @@ class BrowserController:
         
     def _handle_console_message(self, msg):
         """Handle console messages from any framework with enhanced error context collection"""
-        log_entry = {
-            "timestamp": time.time(),
-            "type": msg.type,
-            "text": msg.text,
-            "location": {
-                "url": msg.location.get("url", "") if msg.location else "",
-                "line": msg.location.get("lineNumber", 0) if msg.location else 0,
-                "column": msg.location.get("columnNumber", 0) if msg.location else 0
-            },
-            "args": [str(arg) for arg in msg.args] if msg.args else [],
-            "stack_trace": getattr(msg, 'stackTrace', None)
-        }
-        self.console_logs.append(log_entry)
-        
-        # Enhanced logging for better correlation
-        if msg.type == "error":
-            self.logger.error(f"Console Error: {msg.text} at {msg.location}")
-            
-            # v2.0 Enhancement: Trigger error context collection for console errors
-            if self.error_context_collector:
-                error_event = {
-                    'type': 'console_error',
-                    'message': msg.text,
-                    'location': log_entry['location'],
-                    'stack_trace': log_entry['stack_trace'],
-                    'timestamp': log_entry['timestamp']
-                }
-                # Capture context asynchronously (don't block the event handler)
-                asyncio.create_task(self._collect_error_context_async(error_event))
-            
-        elif msg.type == "warning":
-            self.logger.warning(f"Console Warning: {msg.text}")
-        elif msg.type in ["log", "info"] and any(keyword in msg.text.lower() for keyword in ["error", "failed", "exception"]):
-            # Catch application logs that indicate errors
-            self.logger.warning(f"App Error Log: {msg.text}")
+        try:
+            log_entry = {
+                "timestamp": time.time(),
+                "type": msg.type,
+                "text": msg.text,
+                "location": {
+                    "url": msg.location.get("url", "") if msg.location else "",
+                    "line": msg.location.get("lineNumber", 0) if msg.location else 0,
+                    "column": msg.location.get("columnNumber", 0) if msg.location else 0
+                },
+                "args": [str(arg) for arg in msg.args] if msg.args else [],
+                "stack_trace": getattr(msg, 'stackTrace', None)
+            }
+            self.console_logs.append(log_entry)
             
-            # v2.0 Enhancement: Collect context for application error logs too
-            if self.error_context_collector:
-                error_event = {
-                    'type': 'app_error_log',
-                    'message': msg.text,
-                    'timestamp': log_entry['timestamp']
-                }
-                asyncio.create_task(self._collect_error_context_async(error_event))
+            # Enhanced logging for better correlation
+            if msg.type == "error":
+                self.logger.error(f"Console Error: {msg.text} at {msg.location}")
+                
+                # v2.0 Enhancement: Trigger error context collection for console errors
+                if self.error_context_collector:
+                    error_event = {
+                        'type': 'console_error',
+                        'message': msg.text,
+                        'location': log_entry['location'],
+                        'stack_trace': log_entry['stack_trace'],
+                        'timestamp': log_entry['timestamp']
+                    }
+                    # Capture context asynchronously (don't block the event handler)
+                    asyncio.create_task(self._collect_error_context_async(error_event))
+                
+            elif msg.type == "warning":
+                self.logger.warning(f"Console Warning: {msg.text}")
+            elif msg.type in ["log", "info"] and any(keyword in msg.text.lower() for keyword in ["error", "failed", "exception"]):
+                # Catch application logs that indicate errors
+                self.logger.warning(f"App Error Log: {msg.text}")
+                
+                # v2.0 Enhancement: Collect context for application error logs too
+                if self.error_context_collector:
+                    error_event = {
+                        'type': 'app_error_log',
+                        'message': msg.text,
+                        'timestamp': log_entry['timestamp']
+                    }
+                    asyncio.create_task(self._collect_error_context_async(error_event))
+        except Exception as e:
+            # Defensive error handling - don't let console message parsing break tests
+            self.logger.debug(f"Console message handler error: {e}")
+            # Continue test execution despite error
     
     def _handle_request(self, request):
         """Handle network requests - framework agnostic"""
-        # Capture complete request data
-        request_data = {
-            "timestamp": time.time(),
-            "type": "request",
-            "url": request.url,
-            "method": request.method,
-            "headers": dict(request.headers),
-            "resource_type": request.resource_type,  # document, xhr, fetch, etc.
-            "is_navigation_request": request.is_navigation_request()
-        }
-        
-        # Capture complete payload data for all request types
-        if request.post_data:
-            request_data["post_data"] = request.post_data
-            request_data["post_data_size"] = len(request.post_data)
+        try:
+            # Capture complete request data
+            request_data = {
+                "timestamp": time.time(),
+                "type": "request",
+                "url": request.url,
+                "method": request.method,
+                "headers": dict(request.headers),
+                "resource_type": request.resource_type,  # document, xhr, fetch, etc.
+                "is_navigation_request": request.is_navigation_request()
+            }
             
-            # Try to parse JSON payloads for better debugging
-            content_type = request.headers.get("content-type", "")
-            if "application/json" in content_type:
-                try:
-                    import json
-                    request_data["parsed_json"] = json.loads(request.post_data)
-                except:
-                    pass
-            elif "application/x-www-form-urlencoded" in content_type:
-                try:
-                    from urllib.parse import parse_qs
-                    request_data["parsed_form"] = parse_qs(request.post_data)
-                except:
-                    pass
-        
-        # Capture query parameters
-        from urllib.parse import urlparse, parse_qs
-        parsed_url = urlparse(request.url)
-        if parsed_url.query:
-            request_data["query_params"] = parse_qs(parsed_url.query)
-            
-        # Capture file uploads
-        if "multipart/form-data" in request.headers.get("content-type", ""):
-            request_data["has_file_upload"] = True
-            # Note: Actual file content not captured for performance/privacy
-            
-        self.network_requests.append(request_data)
-        
-        # Enhanced logging for correlation
-        if request.resource_type in ["xhr", "fetch"] or "/api/" in request.url:
-            payload_info = ""
-            if request.post_data:
-                payload_info = f" (payload: {len(request.post_data)} bytes)"
-            self.logger.debug(f"API Request: {request.method} {request.url}{payload_info}")
-            
-            # Log critical data for immediate debugging
-            if request.post_data and len(request.post_data) < 500:  # Only log small payloads
-                self.logger.debug(f"Request payload: {request.post_data}")
+            # Capture complete payload data for all request types
+            # Wrap in try/except to handle gzip-compressed data gracefully
+            try:
+                if request.post_data:
+                    request_data["post_data"] = request.post_data
+                    request_data["post_data_size"] = len(request.post_data)
+                    
+                    # Try to parse JSON payloads for better debugging
+                    content_type = request.headers.get("content-type", "")
+                    if "application/json" in content_type:
+                        try:
+                            import json
+                            request_data["parsed_json"] = json.loads(request.post_data)
+                        except:
+                            pass
+                    elif "application/x-www-form-urlencoded" in content_type:
+                        try:
+                            from urllib.parse import parse_qs
+                            request_data["parsed_form"] = parse_qs(request.post_data)
+                        except:
+                            pass
+            except UnicodeDecodeError:
+                # Handle gzip-compressed or binary data gracefully
+                # This happens when Playwright can't decode the post_data (e.g., gzip magic bytes 0x1f 0x8b)
+                request_data["post_data"] = "[binary/compressed data]"
+                request_data["post_data_size"] = 0
+                self.logger.debug(f"Binary/compressed POST data detected for {request.url}")
+            except Exception as e:
+                # Graceful degradation - don't let post_data parsing break request tracking
+                request_data["post_data"] = None
+                request_data["post_data_size"] = 0
+                self.logger.debug(f"Could not capture post_data for {request.url}: {e}")
+            
+            # Capture query parameters
+            from urllib.parse import urlparse, parse_qs
+            parsed_url = urlparse(request.url)
+            if parsed_url.query:
+                request_data["query_params"] = parse_qs(parsed_url.query)
+                
+            # Capture file uploads
+            if "multipart/form-data" in request.headers.get("content-type", ""):
+                request_data["has_file_upload"] = True
+                # Note: Actual file content not captured for performance/privacy
+                
+            self.network_requests.append(request_data)
+            
+            # Enhanced logging for correlation
+            if request.resource_type in ["xhr", "fetch"] or "/api/" in request.url:
+                payload_info = ""
+                post_data_value = request_data.get("post_data")
+                post_data_size = request_data.get("post_data_size", 0)
+                if post_data_value and post_data_size > 0:
+                    payload_info = f" (payload: {post_data_size} bytes)"
+                self.logger.debug(f"API Request: {request.method} {request.url}{payload_info}")
+                
+                # Log critical data for immediate debugging
+                if post_data_value and post_data_size > 0 and post_data_size < 500:  # Only log small payloads
+                    self.logger.debug(f"Request payload: {post_data_value}")
+        except Exception as e:
+            # Top-level defensive error handling - don't let request handler break event listeners
+            self.logger.debug(f"Request handler error: {e}")
+            # Continue test execution despite error
     
     def _handle_response(self, response):
         """Handle network responses with enhanced error context collection"""
-        response_data = {
-            "timestamp": time.time(),
-            "type": "response", 
-            "url": response.url,
-            "status": response.status,
-            "status_text": response.status_text,
-            "headers": dict(response.headers),
-            "size": 0,  # Will be populated by _capture_response_body if needed
-            "from_cache": response.from_service_worker or False
-        }
-        self.network_requests.append(response_data)
-        
-        # Capture response body asynchronously (Phase 1.4: Network Response Body Capture)
-        asyncio.create_task(self._capture_response_body_async(response, response_data))
-        
-        # Log failed requests for correlation
-        if response.status >= 400:
-            self.logger.warning(f"Failed Response: {response.status} {response.url}")
+        try:
+            response_data = {
+                "timestamp": time.time(),
+                "type": "response", 
+                "url": response.url,
+                "status": response.status,
+                "status_text": response.status_text,
+                "headers": dict(response.headers),
+                "size": 0,  # Will be populated by _capture_response_body if needed
+                "from_cache": response.from_service_worker or False
+            }
+            self.network_requests.append(response_data)
             
-            # v2.0 Enhancement: Trigger error context collection for failed requests
-            if self.error_context_collector:
-                error_event = {
-                    'type': 'network_error',
-                    'url': response.url,
-                    'status': response.status,
-                    'status_text': response.status_text,
-                    'headers': dict(response.headers),
-                    'timestamp': response_data['timestamp']
-                }
-                # Capture context asynchronously
-                asyncio.create_task(self._collect_error_context_async(error_event))
-        
-        # Capture response body for important requests
-        should_capture_body = (
-            response.status >= 400 or  # All error responses
-            any(api_path in response.url for api_path in ["/api/", "/ajax", ".json"]) or  # API calls
-            "application/json" in response.headers.get("content-type", "")  # JSON responses
-        )
-        
-        if should_capture_body:
-            asyncio.create_task(self._capture_response_body(response))
+            # Capture response body asynchronously (Phase 1.4: Network Response Body Capture)
+            asyncio.create_task(self._capture_response_body_async(response, response_data))
+            
+            # Log failed requests for correlation
+            if response.status >= 400:
+                self.logger.warning(f"Failed Response: {response.status} {response.url}")
+                
+                # v2.0 Enhancement: Trigger error context collection for failed requests
+                if self.error_context_collector:
+                    error_event = {
+                        'type': 'network_error',
+                        'url': response.url,
+                        'status': response.status,
+                        'status_text': response.status_text,
+                        'headers': dict(response.headers),
+                        'timestamp': response_data['timestamp']
+                    }
+                    # Capture context asynchronously
+                    asyncio.create_task(self._collect_error_context_async(error_event))
+            
+            # Capture response body for important requests
+            should_capture_body = (
+                response.status >= 400 or  # All error responses
+                any(api_path in response.url for api_path in ["/api/", "/ajax", ".json"]) or  # API calls
+                "application/json" in response.headers.get("content-type", "")  # JSON responses
+            )
+            
+            if should_capture_body:
+                asyncio.create_task(self._capture_response_body(response))
+        except Exception as e:
+            # Defensive error handling - don't let response handler break event listeners
+            self.logger.debug(f"Response handler error: {e}")
+            # Continue test execution despite error
     
     def _handle_page_error(self, error):
         """Handle page errors from any framework"""
-        self.console_logs.append({
-            "timestamp": time.time(),
-            "type": "pageerror",
-            "text": str(error),
-            "location": None
-        })
-        self.logger.error(f"Page error: {error}")
+        try:
+            self.console_logs.append({
+                "timestamp": time.time(),
+                "type": "pageerror",
+                "text": str(error),
+                "location": None
+            })
+            self.logger.error(f"Page error: {error}")
+        except Exception as e:
+            # Defensive error handling - don't let page error handler break event listeners
+            self.logger.debug(f"Page error handler error: {e}")
+            # Continue test execution despite error
     
     def _handle_page_crash(self, page):
         """Handle page crashes"""
-        self.logger.error("Page crashed - attempting recovery")
+        try:
+            self.logger.error("Page crashed - attempting recovery")
+        except Exception as e:
+            # Defensive error handling - don't let crash handler break event listeners
+            self.logger.debug(f"Page crash handler error: {e}")
+            # Continue test execution despite error
     
     async def navigate(self, path: str, wait_for_load: bool = True):
         """Navigate to URL - works with any web framework"""
@@ -2481,15 +2521,28 @@ class BrowserController:
                                 resource_analysis: Dict = None, storage_analysis: Dict = None) -> Dict[str, Any]:
         """Enhanced analysis summary with v2.0 comprehensive data"""
         try:
+            # Safe value extraction with null-safety
+            error_count = console_data.get("console_summary", {}).get("error_count") or 0
+            failed_requests = network_data.get("failed_requests", {}).get("count") or 0
+            page_load_time = performance_data.get("performance_summary", {}).get("page_load_time") or 0
+            
+            # Ensure numeric values are actually numeric (not None)
+            if not isinstance(error_count, (int, float)):
+                error_count = 0
+            if not isinstance(failed_requests, (int, float)):
+                failed_requests = 0
+            if not isinstance(page_load_time, (int, float)):
+                page_load_time = 0
+            
             # Base summary (v1.x compatibility)
             summary = {
                 "page_health": {
                     "dom_elements_count": dom_analysis.get("totalElements", 0),
-                    "has_errors": console_data.get("console_summary", {}).get("error_count", 0) > 0,
-                    "error_count": console_data.get("console_summary", {}).get("error_count", 0),
+                    "has_errors": error_count > 0,
+                    "error_count": error_count,
                     "warning_count": console_data.get("console_summary", {}).get("warning_count", 0),
                     "failed_requests": network_data.get("network_summary", {}).get("failed_requests", 0),
-                    "page_load_time_ms": performance_data.get("performance_summary", {}).get("page_load_time", 0)
+                    "page_load_time_ms": page_load_time
                 },
                 "interaction_readiness": {
                     "interactive_elements": dom_analysis.get("pageStructure", {}).get("interactiveElements", 0),
@@ -2505,12 +2558,12 @@ class BrowserController:
                 },
                 "quality_indicators": {
                     "has_console_errors": console_data.get("console_summary", {}).get("has_recent_errors", False),
-                    "has_failed_requests": network_data.get("failed_requests", {}).get("count", 0) > 0,
+                    "has_failed_requests": failed_requests > 0,
                     "performance_score": self._calculate_performance_score(performance_data),
                     "overall_health": "good" if (
-                        console_data.get("console_summary", {}).get("error_count", 0) == 0 and
-                        network_data.get("failed_requests", {}).get("count", 0) == 0 and
-                        performance_data.get("performance_summary", {}).get("page_load_time", 0) < 3000
+                        error_count == 0 and
+                        failed_requests == 0 and
+                        page_load_time < 3000
                     ) else "needs_attention"
                 }
             }

{cursorflow-2.6.1 → cursorflow-2.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cursorflow"
-version = "2.6.1"
+version = "2.6.3"
 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"}