cursorflow 2.7.1__tar.gz → 2.7.2__tar.gz

{cursorflow-2.7.1 → cursorflow-2.7.2}/PKG-INFO

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

@@ -1151,6 +1151,8 @@ def inspect(base_url, path, selector, verbose):
         results = asyncio.run(flow.execute_and_collect([
             {"navigate": path},
             {"wait_for_selector": "body"},
+            {"wait_for_load_state": "networkidle"},  # Wait for dynamic content
+            {"wait_for_timeout": 1000},  # Additional buffer for JS rendering (1s)
             {"screenshot": "inspection"}
         ]))
         
@@ -1200,7 +1202,7 @@ def inspect(base_url, path, selector, verbose):
                 console.print(f"Classes:   [blue].{classes}[/blue]")
             
             # Selectors
-            unique_selector = element.get('uniqueSelector', 'N/A')
+            unique_selector = escape(str(element.get('uniqueSelector', 'N/A')))
             console.print(f"Unique:    [cyan]{unique_selector}[/cyan]")
             
             # Dimensions
@@ -1216,20 +1218,22 @@ def inspect(base_url, path, selector, verbose):
                 console.print(f"\n🎨 Key CSS Properties:")
                 
                 # Layout
-                display = computed.get('display', 'N/A')
-                position = computed.get('position', 'N/A')
+                display = escape(str(computed.get('display', 'N/A')))
+                position = escape(str(computed.get('position', 'N/A')))
                 console.print(f"   display:   {display}")
                 console.print(f"   position:  {position}")
                 
                 # Flexbox
                 if 'flex' in computed:
-                    console.print(f"   flex:      {computed.get('flex', 'N/A')}")
+                    flex_value = escape(str(computed.get('flex', 'N/A')))
+                    console.print(f"   flex:      {flex_value}")
                 if 'flexBasis' in computed:
-                    console.print(f"   flex-basis: {computed.get('flexBasis', 'N/A')}")
+                    flex_basis = escape(str(computed.get('flexBasis', 'N/A')))
+                    console.print(f"   flex-basis: {flex_basis}")
                 
                 # Dimensions
-                width = computed.get('width', 'N/A')
-                height = computed.get('height', 'N/A')
+                width = escape(str(computed.get('width', 'N/A')))
+                height = escape(str(computed.get('height', 'N/A')))
                 console.print(f"   width:     {width}")
                 console.print(f"   height:    {height}")
                 
@@ -1237,20 +1241,23 @@ def inspect(base_url, path, selector, verbose):
                 margin = computed.get('margin', 'N/A')
                 padding = computed.get('padding', 'N/A')
                 if margin != 'N/A':
+                    margin = escape(str(margin))
                     console.print(f"   margin:    {margin}")
                 if padding != 'N/A':
+                    padding = escape(str(padding))
                     console.print(f"   padding:   {padding}")
                 
                 # Show all styles in verbose mode
                 if verbose:
                     console.print(f"\n📋 All Computed Styles:")
                     for prop, value in sorted(computed.items())[:30]:  # Limit to 30
-                        console.print(f"   {prop}: {value}")
+                        safe_value = escape(str(value))
+                        console.print(f"   {prop}: {safe_value}")
             
             # Accessibility info
             accessibility = element.get('accessibility', {})
             if accessibility:
-                role = accessibility.get('role', 'N/A')
+                role = escape(str(accessibility.get('role', 'N/A')))
                 is_interactive = accessibility.get('isInteractive', False)
                 console.print(f"\n♿ Accessibility:")
                 console.print(f"   Role:         {role}")
@@ -1293,8 +1300,9 @@ def inspect(base_url, path, selector, verbose):
         
     except Exception as e:
         console.print(f"[red]❌ Inspection failed: {escape(str(e))}[/red]")
-        import traceback
-        console.print(traceback.format_exc())
+        if verbose:
+            import traceback
+            console.print(escape(traceback.format_exc()))
 
 def _element_matches_selector(element: Dict, selector: str) -> bool:
     """Check if element matches the given selector"""

{cursorflow-2.7.1 → cursorflow-2.7.2}/cursorflow/core/output_manager.py

@@ -146,31 +146,28 @@ class OutputManager:
     
     def _extract_summary(self, results: Dict) -> Dict:
         """Extract high-level summary data"""
-        comprehensive = results.get('comprehensive_data', {})
+        # Load comprehensive data from disk if available
+        comprehensive = self._load_comprehensive_data(results)
         artifacts = results.get('artifacts', {})
         
-        # Count errors
+        # Count errors from comprehensive_data
         error_count = 0
         warning_count = 0
-        console_screenshots = artifacts.get('console_errors', [])
-        for screenshot in console_screenshots:
-            if isinstance(screenshot, dict):
-                console_data = screenshot.get('console_data', {})
-                errors = console_data.get('errors', {})
-                error_count += len(errors.get('logs', []))
-                warnings = console_data.get('warnings', {})
-                warning_count += len(warnings.get('logs', []))
+        if comprehensive:
+            console_data = comprehensive.get('console_data', {})
+            all_console_logs = console_data.get('all_console_logs', [])
+            error_count = len([log for log in all_console_logs if log.get('type') == 'error'])
+            warning_count = len([log for log in all_console_logs if log.get('type') == 'warning'])
         
-        # Count network requests
+        # Count network requests from comprehensive_data
         network_count = 0
         failed_network_count = 0
-        for screenshot in artifacts.get('screenshots', []):
-            if isinstance(screenshot, dict):
-                network_data = screenshot.get('network_data', {})
-                requests = network_data.get('requests', [])
-                network_count += len(requests)
-                failed_requests = network_data.get('failed_requests', {})
-                failed_network_count += len(failed_requests.get('requests', []))
+        if comprehensive:
+            network_data = comprehensive.get('network_data', {})
+            all_network_events = network_data.get('all_network_events', [])
+            network_count = len(all_network_events)
+            # Count failures (4xx, 5xx)
+            failed_network_count = len([req for req in all_network_events if req.get('status', 0) >= 400])
         
         # Count DOM elements
         dom_element_count = 0
@@ -202,26 +199,50 @@ class OutputManager:
     
     def _extract_errors(self, results: Dict) -> Dict:
         """Extract all error data with context"""
-        artifacts = results.get('artifacts', {})
         errors = []
         
-        # Collect errors from all screenshots
-        for screenshot in artifacts.get('screenshots', []):
-            if isinstance(screenshot, dict):
-                console_data = screenshot.get('console_data', {})
-                error_logs = console_data.get('errors', {}).get('logs', [])
-                
-                for error in error_logs:
+        # Load comprehensive data from disk if available
+        comprehensive_data = self._load_comprehensive_data(results)
+        
+        if comprehensive_data:
+            console_data = comprehensive_data.get('console_data', {})
+            all_console_logs = console_data.get('all_console_logs', [])
+            
+            # Filter for errors
+            for log in all_console_logs:
+                if log.get('type') == 'error':
+                    # Extract location info if present
+                    location = log.get('location', {})
                     errors.append({
-                        "message": error.get('message', ''),
-                        "source": error.get('source', ''),
-                        "line": error.get('line', 0),
-                        "column": error.get('column', 0),
-                        "stack_trace": error.get('stack_trace', ''),
-                        "timestamp": screenshot.get('timestamp', 0),
-                        "screenshot_name": screenshot.get('name', 'unknown'),
-                        "url": screenshot.get('url', '')
+                        "message": log.get('text', ''),
+                        "source": location.get('url', ''),
+                        "line": location.get('lineNumber', 0),
+                        "column": location.get('columnNumber', 0),
+                        "stack_trace": log.get('stackTrace', {}).get('callFrames', []),
+                        "timestamp": log.get('timestamp', 0),
+                        "screenshot_name": 'comprehensive',
+                        "url": location.get('url', '')
                     })
+        else:
+            # Fallback: Collect errors from screenshot artifacts (old structure)
+            # Only if comprehensive_data not available
+            artifacts = results.get('artifacts', {})
+            for screenshot in artifacts.get('screenshots', []):
+                if isinstance(screenshot, dict):
+                    console_data = screenshot.get('console_data', {})
+                    error_logs = console_data.get('errors', {}).get('logs', [])
+                    
+                    for error in error_logs:
+                        errors.append({
+                            "message": error.get('message', ''),
+                            "source": error.get('source', ''),
+                            "line": error.get('line', 0),
+                            "column": error.get('column', 0),
+                            "stack_trace": error.get('stack_trace', ''),
+                            "timestamp": screenshot.get('timestamp', 0),
+                            "screenshot_name": screenshot.get('name', 'unknown'),
+                            "url": screenshot.get('url', '')
+                        })
         
         # Organize by error type
         error_types = {}
@@ -243,29 +264,55 @@ class OutputManager:
     
     def _extract_network(self, results: Dict) -> Dict:
         """Extract network request/response data"""
-        artifacts = results.get('artifacts', {})
         all_requests = []
         failed_requests = []
         
-        for screenshot in artifacts.get('screenshots', []):
-            if isinstance(screenshot, dict):
-                network_data = screenshot.get('network_data', {})
-                requests = network_data.get('requests', [])
-                
-                for request in requests:
-                    all_requests.append({
-                        **request,
-                        "screenshot_name": screenshot.get('name', 'unknown'),
-                        "timestamp": screenshot.get('timestamp', 0)
-                    })
+        # Load comprehensive data from disk if available
+        comprehensive_data = self._load_comprehensive_data(results)
+        
+        if comprehensive_data:
+            network_data = comprehensive_data.get('network_data', {})
+            all_network_events = network_data.get('all_network_events', [])
+            
+            # Add all network events and identify failures
+            for event in all_network_events:
+                request_data = {
+                    "url": event.get('url', ''),
+                    "method": event.get('method', 'GET'),
+                    "status_code": event.get('status', 0),
+                    "timestamp": event.get('timestamp', 0),
+                    "timing": event.get('timing', {}),
+                    "screenshot_name": 'comprehensive'
+                }
+                all_requests.append(request_data)
                 
-                failed = network_data.get('failed_requests', {}).get('requests', [])
-                for request in failed:
-                    failed_requests.append({
-                        **request,
-                        "screenshot_name": screenshot.get('name', 'unknown'),
-                        "timestamp": screenshot.get('timestamp', 0)
-                    })
+                # Identify failed requests (4xx, 5xx status codes)
+                status = event.get('status', 0)
+                if status >= 400:
+                    failed_requests.append(request_data)
+        else:
+            # Fallback: Collect from screenshot artifacts (old structure)
+            # Only if comprehensive_data not available
+            artifacts = results.get('artifacts', {})
+            for screenshot in artifacts.get('screenshots', []):
+                if isinstance(screenshot, dict):
+                    network_data = screenshot.get('network_data', {})
+                    requests = network_data.get('requests', [])
+                    
+                    for request in requests:
+                        all_requests.append({
+                            **request,
+                            "screenshot_name": screenshot.get('name', 'unknown'),
+                            "timestamp": screenshot.get('timestamp', 0)
+                        })
+                    
+                    failed = network_data.get('failed_requests', {}).get('requests', [])
+                    for request in failed:
+                        failed_requests.append({
+                            **request,
+                            "screenshot_name": screenshot.get('name', 'unknown'),
+                            "timestamp": screenshot.get('timestamp', 0)
+                        })
         
         # Organize by status code
         by_status_code = {}
@@ -288,24 +335,42 @@ class OutputManager:
     
     def _extract_console(self, results: Dict) -> Dict:
         """Extract all console messages"""
-        artifacts = results.get('artifacts', {})
         all_messages = []
         
-        for screenshot in artifacts.get('screenshots', []):
-            if isinstance(screenshot, dict):
-                console_data = screenshot.get('console_data', {})
-                
-                # Collect all message types
-                for msg_type in ['errors', 'warnings', 'logs', 'info']:
-                    messages = console_data.get(msg_type, {}).get('logs', [])
-                    for msg in messages:
-                        all_messages.append({
-                            "type": msg_type,
-                            "message": msg.get('message', ''),
-                            "source": msg.get('source', ''),
-                            "timestamp": screenshot.get('timestamp', 0),
-                            "screenshot_name": screenshot.get('name', 'unknown')
-                        })
+        # Load comprehensive data from disk if available
+        comprehensive_data = self._load_comprehensive_data(results)
+        
+        if comprehensive_data:
+            console_data = comprehensive_data.get('console_data', {})
+            all_console_logs = console_data.get('all_console_logs', [])
+            
+            for log in all_console_logs:
+                all_messages.append({
+                    "type": log.get('type', 'log'),
+                    "message": log.get('text', ''),
+                    "source": log.get('location', {}).get('url', ''),
+                    "timestamp": log.get('timestamp', 0),
+                    "screenshot_name": 'comprehensive'
+                })
+        else:
+            # Fallback: Collect from screenshot artifacts (old structure)
+            # Only if comprehensive_data not available
+            artifacts = results.get('artifacts', {})
+            for screenshot in artifacts.get('screenshots', []):
+                if isinstance(screenshot, dict):
+                    console_data = screenshot.get('console_data', {})
+                    
+                    # Collect all message types
+                    for msg_type in ['errors', 'warnings', 'logs', 'info']:
+                        messages = console_data.get(msg_type, {}).get('logs', [])
+                        for msg in messages:
+                            all_messages.append({
+                                "type": msg_type,
+                                "message": msg.get('message', ''),
+                                "source": msg.get('source', ''),
+                                "timestamp": screenshot.get('timestamp', 0),
+                                "screenshot_name": screenshot.get('name', 'unknown')
+                            })
         
         # Organize by type
         by_type = {}
@@ -335,9 +400,22 @@ class OutputManager:
     
     def _extract_performance(self, results: Dict) -> Dict:
         """Extract performance metrics"""
-        artifacts = results.get('artifacts', {})
         performance_data = []
         
+        # Load comprehensive data from disk if available
+        comprehensive = self._load_comprehensive_data(results)
+        
+        if comprehensive and 'performance_data' in comprehensive:
+            perf = comprehensive.get('performance_data', {})
+            if perf:
+                performance_data.append({
+                    "screenshot_name": 'comprehensive',
+                    "timestamp": results.get('execution_time', 0),
+                    "metrics": perf
+                })
+        
+        # Fallback: from screenshot artifacts
+        artifacts = results.get('artifacts', {})
         for screenshot in artifacts.get('screenshots', []):
             if isinstance(screenshot, dict):
                 perf = screenshot.get('performance_data', {})
@@ -512,6 +590,44 @@ class OutputManager:
             "min_memory_usage": min(memory_usage) if memory_usage else 0
         }
     
+    def _load_comprehensive_data(self, results: Dict) -> Dict:
+        """Load comprehensive data from disk or from results dict"""
+        # First try to get from results (if already loaded)
+        comprehensive = results.get('comprehensive_data', {})
+        if comprehensive:
+            return comprehensive
+        
+        # Try to load from disk via screenshot artifacts
+        artifacts = results.get('artifacts', {})
+        screenshots = artifacts.get('screenshots', [])
+        
+        if screenshots:
+            last_screenshot = screenshots[-1]
+            # Check if comprehensive_data_path is set
+            if isinstance(last_screenshot, dict) and 'comprehensive_data_path' in last_screenshot:
+                comp_path = Path(last_screenshot['comprehensive_data_path'])
+                if comp_path.exists():
+                    try:
+                        with open(comp_path, 'r', encoding='utf-8') as f:
+                            return json.load(f)
+                    except Exception as e:
+                        self.logger.warning(f"Could not load comprehensive data from {comp_path}: {e}")
+            
+            # Try to find comprehensive data file by naming convention
+            if isinstance(last_screenshot, dict) and 'path' in last_screenshot:
+                screenshot_path = Path(last_screenshot['path'])
+                if screenshot_path.exists():
+                    # Look for companion comprehensive data file
+                    comp_path = screenshot_path.parent / f"{screenshot_path.stem}_comprehensive_data.json"
+                    if comp_path.exists():
+                        try:
+                            with open(comp_path, 'r', encoding='utf-8') as f:
+                                return json.load(f)
+                        except Exception as e:
+                            self.logger.warning(f"Could not load comprehensive data from {comp_path}: {e}")
+        
+        return {}
+    
     def _write_json(self, path: Path, data: Dict):
         """Write JSON data to file with proper formatting"""
         with open(path, 'w', encoding='utf-8') as f:

{cursorflow-2.7.1 → cursorflow-2.7.2}/cursorflow/core/query_engine.py

@@ -317,11 +317,8 @@ class QueryEngine:
         
         # Filter failed requests only
         if 'failed' in filters and filters['failed']:
-            failed_reqs = network.get('failed_requests', [])
-            filtered_requests = [
-                req for req in all_requests
-                if req.get('url') in [f.get('url') for f in failed_reqs]
-            ]
+            # Use failed_requests array directly (already filtered)
+            filtered_requests = network.get('failed_requests', [])
         
         # Phase 1: Enhanced network filtering
         

{cursorflow-2.7.1 → cursorflow-2.7.2}/pyproject.toml

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