cursorflow 2.6.3__py3-none-any.whl → 2.7.2__py3-none-any.whl

cursorflow/cli.py

@@ -18,6 +18,9 @@ from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.markup import escape
 
 from .core.agent import TestAgent
+from .core.output_manager import OutputManager
+from .core.data_presenter import DataPresenter
+from .core.query_engine import QueryEngine
 from . import __version__
 
 console = Console()
@@ -293,20 +296,35 @@ def test(base_url, path, actions, output, logs, config, verbose, headless, timeo
             if timeline:
                 console.print(f"⏰ Timeline events: {len(timeline)}")
         
-        # Save results to file for Cursor analysis
-        if not output:
-            # Auto-generate meaningful filename in .cursorflow/artifacts/
-            session_id = results.get('session_id', 'unknown')
-            path_part = path.replace('/', '_') if path else 'root'
-            
-            # Ensure .cursorflow/artifacts directory exists
-            artifacts_dir = Path('.cursorflow/artifacts')
-            artifacts_dir.mkdir(parents=True, exist_ok=True)
-            
-            output = artifacts_dir / f"cursorflow_{path_part}_{session_id}.json"
+        # Save results in structured multi-file format
+        session_id = results.get('session_id', 'unknown')
+        test_desc = path if path else 'test'
         
-        with open(output, 'w') as f:
-            json.dump(results, f, indent=2, default=str)
+        # Use output manager to save structured results
+        output_mgr = OutputManager()
+        file_paths = output_mgr.save_structured_results(
+            results, 
+            session_id, 
+            test_desc
+        )
+        
+        # Generate AI-optimized data digest
+        session_dir = output_mgr.get_session_path(session_id)
+        data_pres = DataPresenter()
+        digest_content = data_pres.generate_data_digest(session_dir, results)
+        
+        digest_path = session_dir / "data_digest.md"
+        with open(digest_path, 'w', encoding='utf-8') as f:
+            f.write(digest_content)
+        file_paths['data_digest'] = str(digest_path)
+        
+        if not quiet:
+            console.print(f"\n📁 [bold green]Results saved to:[/bold green] [cyan]{session_dir}[/cyan]")
+            console.print(f"📄 [bold]AI Summary:[/bold] [cyan]{digest_path}[/cyan]")
+            console.print(f"\n💡 [dim]Quick commands:[/dim]")
+            console.print(f"   cursorflow query {session_id} --errors")
+            console.print(f"   cursorflow query {session_id} --network")
+            console.print(f"   cat {digest_path}")
         
         # Save command for rerun (Phase 3.3)
         last_test_data = {
@@ -346,6 +364,320 @@ def test(base_url, path, actions, output, logs, config, verbose, headless, timeo
             console.print(traceback.format_exc())
         raise
 
+
+@main.command()
+@click.argument('session_id', required=False)
+@click.option('--errors', is_flag=True, help='Query error data')
+@click.option('--network', is_flag=True, help='Query network requests')
+@click.option('--console', 'console_opt', is_flag=True, help='Query console messages')
+@click.option('--performance', is_flag=True, help='Query performance metrics')
+@click.option('--summary', is_flag=True, help='Query summary data')
+@click.option('--dom', is_flag=True, help='Query DOM analysis')
+@click.option('--server-logs', is_flag=True, help='Query server logs')
+@click.option('--screenshots', is_flag=True, help='Query screenshot metadata')
+@click.option('--mockup', is_flag=True, help='Query mockup comparison results')
+@click.option('--responsive', is_flag=True, help='Query responsive testing results')
+@click.option('--css-iterations', is_flag=True, help='Query CSS iteration results')
+@click.option('--timeline', is_flag=True, help='Query timeline events')
+@click.option('--severity', type=str, help='Filter errors by severity (critical)')
+@click.option('--level', type=str, help='Filter server logs by level (error,warning,info)')
+@click.option('--status', type=str, help='Filter network by status codes (404,500 or 4xx,5xx)')
+@click.option('--failed', is_flag=True, help='Show only failed network requests')
+@click.option('--type', type=str, help='Filter console by type (error,warning,log,info)')
+@click.option('--selector', type=str, help='Filter DOM by CSS selector')
+@click.option('--source', type=str, help='Filter server logs by source (ssh,local,docker,systemd)')
+@click.option('--file', type=str, help='Filter server logs by file path')
+@click.option('--pattern', type=str, help='Filter by content pattern')
+@click.option('--contains', type=str, help='Filter by content substring')
+@click.option('--matches', type=str, help='Filter by regex pattern')
+@click.option('--from-file', type=str, help='Filter errors by source file')
+@click.option('--from-pattern', type=str, help='Filter errors by file pattern (*.js, *.ts)')
+@click.option('--url-contains', type=str, help='Filter network by URL substring')
+@click.option('--url-matches', type=str, help='Filter network by URL regex')
+@click.option('--over', type=str, help='Filter network requests over timing threshold (500ms)')
+@click.option('--method', type=str, help='Filter network by HTTP method (GET,POST)')
+@click.option('--visible', is_flag=True, help='Filter DOM to visible elements only')
+@click.option('--interactive', is_flag=True, help='Filter DOM to interactive elements only')
+@click.option('--role', type=str, help='Filter DOM by ARIA role')
+@click.option('--with-attr', type=str, help='Filter DOM by attribute name')
+@click.option('--with-network', is_flag=True, help='Include related network requests (cross-ref)')
+@click.option('--with-console', is_flag=True, help='Include related console messages (cross-ref)')
+@click.option('--with-server-logs', is_flag=True, help='Include related server logs (cross-ref)')
+@click.option('--context-for-error', type=int, help='Get full context for error by index')
+@click.option('--group-by-url', type=str, help='Group all data by URL pattern')
+@click.option('--group-by-selector', type=str, help='Group all data by DOM selector')
+@click.option('--viewport', type=str, help='Filter responsive results by viewport (mobile,tablet,desktop)')
+@click.option('--iteration', type=int, help='Filter by specific iteration number')
+@click.option('--with-errors', is_flag=True, help='Filter screenshots/iterations with errors only')
+@click.option('--around', type=float, help='Query timeline events around timestamp')
+@click.option('--window', type=float, default=5.0, help='Time window in seconds (default: 5)')
+@click.option('--export', type=click.Choice(['json', 'markdown', 'csv']), 
+              default='json', help='Export format')
+@click.option('--compare-with', type=str, help='Compare with another session')
+@click.option('--list', 'list_sessions', is_flag=True, help='List recent sessions')
+@click.option('--verbose', '-v', is_flag=True, help='Verbose output')
+def query(session_id, errors, network, console_opt, performance, summary, dom,
+         server_logs, screenshots, mockup, responsive, css_iterations, timeline,
+         severity, level, status, failed, type, selector, source, file, pattern, 
+         contains, matches, from_file, from_pattern, url_contains, url_matches, over, method,
+         visible, interactive, role, with_attr, with_network, with_console, with_server_logs,
+         context_for_error, group_by_url, group_by_selector,
+         viewport, iteration, with_errors, around, window,
+         export, compare_with, list_sessions, verbose):
+    """
+    Query and filter CursorFlow test results
+    
+    Examples:
+    
+        # List recent sessions
+        cursorflow query --list
+        
+        # Query errors from a session
+        cursorflow query session_123 --errors
+        
+        # Query server logs
+        cursorflow query session_123 --server-logs --severity error
+        
+        # Query network failures
+        cursorflow query session_123 --network --failed
+        
+        # Query responsive results
+        cursorflow query session_123 --responsive --viewport mobile
+        
+        # Export in different formats
+        cursorflow query session_123 --errors --export markdown
+        
+        # Compare two sessions
+        cursorflow query session_123 --compare-with session_456
+    """
+    
+    engine = QueryEngine()
+    
+    # List sessions mode
+    if list_sessions:
+        _list_sessions_func(engine)
+        return
+    
+    if not session_id:
+        console.print("[yellow]⚠️  Provide a session_id or use --list to see available sessions[/yellow]")
+        console.print("Example: [cyan]cursorflow query session_123 --errors[/cyan]")
+        return
+    
+    # Comparison mode
+    if compare_with:
+        _compare_sessions_func(engine, session_id, compare_with, errors, network, performance)
+        return
+    
+    # Determine query type
+    query_type = None
+    if errors:
+        query_type = 'errors'
+    elif network:
+        query_type = 'network'
+    elif console_opt:
+        query_type = 'console'
+    elif performance:
+        query_type = 'performance'
+    elif summary:
+        query_type = 'summary'
+    elif dom:
+        query_type = 'dom'
+    elif server_logs:
+        query_type = 'server_logs'
+    elif screenshots:
+        query_type = 'screenshots'
+    elif mockup:
+        query_type = 'mockup'
+    elif responsive:
+        query_type = 'responsive'
+    elif css_iterations:
+        query_type = 'css_iterations'
+    elif timeline:
+        query_type = 'timeline'
+    
+    # Build filters
+    filters = {}
+    if severity:
+        filters['severity'] = severity
+    if level:
+        filters['level'] = level
+    if status:
+        filters['status'] = status
+    if failed:
+        filters['failed'] = True
+    if type:
+        filters['type'] = type
+    if selector:
+        filters['selector'] = selector
+    if source:
+        filters['source'] = source
+    if file:
+        filters['file'] = file
+    if pattern:
+        filters['pattern'] = pattern
+    if contains:
+        filters['contains'] = contains
+    if matches:
+        filters['matches'] = matches
+    if from_file:
+        filters['from_file'] = from_file
+    if from_pattern:
+        filters['from_pattern'] = from_pattern
+    if url_contains:
+        filters['url_contains'] = url_contains
+    if url_matches:
+        filters['url_matches'] = url_matches
+    if over:
+        filters['over'] = over
+    if method:
+        filters['method'] = method
+    if visible:
+        filters['visible'] = True
+    if interactive:
+        filters['interactive'] = True
+    if role:
+        filters['role'] = role
+    if with_attr:
+        filters['with_attr'] = with_attr
+    if with_network:
+        filters['with_network'] = True
+    if with_console:
+        filters['with_console'] = True
+    if with_server_logs:
+        filters['with_server_logs'] = True
+    if context_for_error is not None:
+        filters['context_for_error'] = context_for_error
+    if group_by_url:
+        filters['group_by_url'] = group_by_url
+    if group_by_selector:
+        filters['group_by_selector'] = group_by_selector
+    if viewport:
+        filters['viewport'] = viewport
+    if iteration:
+        filters['iteration'] = iteration
+    if with_errors:
+        filters['with_errors'] = True
+    if around:
+        filters['around'] = around
+        filters['window'] = window
+    
+    try:
+        # Execute query
+        result = engine.query_session(session_id, query_type, filters, export)
+        
+        # Display results
+        if export == 'json':
+            if verbose:
+                console.print(result)
+            else:
+                # Pretty print JSON
+                data = json.loads(result)
+                console.print_json(data=data)
+        else:
+            console.print(result)
+    
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        console.print(f"\n💡 [dim]Tip:[/dim] List available sessions with: [cyan]cursorflow query --list[/cyan]")
+    except Exception as e:
+        console.print(f"[red]Error querying session:[/red] {e}")
+        if verbose:
+            import traceback
+            console.print(traceback.format_exc())
+
+
+def _list_sessions_func(engine: QueryEngine):
+    """List recent sessions"""
+    sessions = engine.list_sessions(limit=10)
+    
+    if not sessions:
+        console.print("[yellow]No sessions found[/yellow]")
+        console.print("Run a test first: [cyan]cursorflow test --base-url http://localhost:3000 --path /[/cyan]")
+        return
+    
+    table = Table(title="Recent Test Sessions", box=box.ROUNDED)
+    table.add_column("Session ID", style="cyan")
+    table.add_column("Timestamp", style="white")
+    table.add_column("Status", style="green")
+    table.add_column("Errors", style="red")
+    table.add_column("Network Failures", style="yellow")
+    
+    for session in sessions:
+        status_emoji = "✅" if session['success'] else "⚠️"
+        table.add_row(
+            session['session_id'],
+            session['timestamp'],
+            status_emoji,
+            str(session['errors']),
+            str(session['network_failures'])
+        )
+    
+    console.print(table)
+    console.print(f"\n💡 [dim]Query a session:[/dim] [cyan]cursorflow query <session_id> --errors[/cyan]")
+
+
+def _compare_sessions_func(engine: QueryEngine, session_a: str, session_b: str, 
+                           errors: bool, network: bool, performance: bool):
+    """Compare two sessions"""
+    try:
+        query_type = None
+        if errors:
+            query_type = 'errors'
+        elif network:
+            query_type = 'network'
+        elif performance:
+            query_type = 'performance'
+        
+        comparison = engine.compare_sessions(session_a, session_b, query_type)
+        
+        console.print(f"\n[bold]Comparing Sessions:[/bold]")
+        console.print(f"  Session A: [cyan]{session_a}[/cyan]")
+        console.print(f"  Session B: [cyan]{session_b}[/cyan]")
+        console.print()
+        
+        # Display summary comparison
+        summary_diff = comparison.get('summary_diff', {})
+        
+        table = Table(title="Summary Comparison", box=box.ROUNDED)
+        table.add_column("Metric", style="white")
+        table.add_column("Session A", style="cyan")
+        table.add_column("Session B", style="cyan")
+        table.add_column("Difference", style="yellow")
+        
+        for metric, values in summary_diff.items():
+            diff = values.get('difference', 0)
+            diff_str = f"+{diff}" if diff > 0 else str(diff)
+            table.add_row(
+                metric.replace('_', ' ').title(),
+                str(values.get('session_a', 0)),
+                str(values.get('session_b', 0)),
+                diff_str
+            )
+        
+        console.print(table)
+        
+        # Display specific comparison if requested
+        if errors and 'errors_diff' in comparison:
+            console.print(f"\n[bold]Errors Comparison:[/bold]")
+            errors_diff = comparison['errors_diff']
+            console.print(f"  New errors: [red]{errors_diff.get('new_errors', 0)}[/red]")
+        
+        if network and 'network_diff' in comparison:
+            console.print(f"\n[bold]Network Comparison:[/bold]")
+            network_diff = comparison['network_diff']
+            console.print(f"  Success rate A: {network_diff.get('success_rate_a', 0):.1f}%")
+            console.print(f"  Success rate B: {network_diff.get('success_rate_b', 0):.1f}%")
+        
+        if performance and 'performance_diff' in comparison:
+            console.print(f"\n[bold]Performance Comparison:[/bold]")
+            perf_diff = comparison['performance_diff']
+            exec_diff = perf_diff.get('execution_time', {}).get('difference', 0)
+            console.print(f"  Execution time difference: {exec_diff:.2f}s")
+    
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+
+
 @main.command()
 @click.argument('mockup_url', required=True)
 @click.option('--base-url', '-u', default='http://localhost:3000',
@@ -819,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"}
         ]))
         
@@ -868,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
@@ -884,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}")
                 
@@ -905,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}")
@@ -961,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/core/cursorflow.py

@@ -21,6 +21,8 @@ from .css_iterator import CSSIterator
 from .cursor_integration import CursorIntegration
 from .persistent_session import PersistentSession, get_session_manager
 from .mockup_comparator import MockupComparator
+from .output_manager import OutputManager
+from .data_presenter import DataPresenter
 
 
 class CursorFlow:
@@ -74,6 +76,10 @@ class CursorFlow:
         self.cursor_integration = CursorIntegration()
         self.mockup_comparator = MockupComparator()
         
+        # Initialize output manager and data presenter
+        self.output_manager = OutputManager()
+        self.data_presenter = DataPresenter()
+        
         # Session tracking
         self.session_id = None
         self.timeline = []
@@ -166,7 +172,8 @@ class CursorFlow:
                 "server_logs": server_logs,       # Raw server logs
                 "summary": summary,               # Basic counts
                 "artifacts": self.artifacts,
-                "comprehensive_data": comprehensive_data  # Complete page intelligence
+                "comprehensive_data": comprehensive_data,  # Complete page intelligence
+                "test_description": session_options.get('test_description', 'test') if session_options else 'test'
             }
             
             self.logger.info(f"Test execution completed: {success}, timeline events: {len(organized_timeline)}")