cursorflow 2.0.3__py3-none-any.whl → 2.1.0__py3-none-any.whl

cursorflow/__init__.py

@@ -18,38 +18,45 @@ from .core.log_monitor import LogMonitor
 from .core.error_correlator import ErrorCorrelator
 
 def _get_version():
-    """Get version from git tag or fallback to default"""
+    """Get version from pyproject.toml or fallback to default"""
     try:
-        import subprocess
-        result = subprocess.run(
-            ['git', 'describe', '--tags', '--exact-match'],
-            capture_output=True,
-            text=True,
-            cwd=Path(__file__).parent.parent
-        )
-        if result.returncode == 0:
-            # Remove 'v' prefix if present
-            return result.stdout.strip().lstrip('v')
+        # Try to read from pyproject.toml first (most reliable)
+        import tomllib
+        pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
+        if pyproject_path.exists():
+            with open(pyproject_path, 'rb') as f:
+                data = tomllib.load(f)
+                return data["project"]["version"]
+    except Exception:
+        pass
+    
+    try:
+        # Try toml library as fallback (for older Python)
+        import toml
+        pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
+        if pyproject_path.exists():
+            with open(pyproject_path, 'r') as f:
+                data = toml.load(f)
+                return data["project"]["version"]
     except Exception:
         pass
     
     try:
-        # Try to get latest tag if not on exact tag
+        # Try git tag as final option
+        import subprocess
         result = subprocess.run(
-            ['git', 'describe', '--tags', '--abbrev=0'],
+            ['git', 'describe', '--tags', '--exact-match'],
             capture_output=True,
             text=True,
             cwd=Path(__file__).parent.parent
         )
         if result.returncode == 0:
-            tag = result.stdout.strip().lstrip('v')
-            # Add dev suffix if not on exact tag
-            return f"{tag}-dev"
+            return result.stdout.strip().lstrip('v')
     except Exception:
         pass
     
     # Fallback version - should match pyproject.toml
-    return "2.0.3"
+    return "2.1.0"
 
 __version__ = _get_version()
 __author__ = "GeekWarrior Development"

cursorflow/cli.py

@@ -46,7 +46,9 @@ def main():
               help='Run browser in headless mode')
 @click.option('--timeout', type=int, default=30,
               help='Timeout in seconds for actions')
-def test(base_url, path, actions, output, logs, config, verbose, headless, timeout):
+@click.option('--responsive', is_flag=True,
+              help='Test across multiple viewports (mobile, tablet, desktop)')
+def test(base_url, path, actions, output, logs, config, verbose, headless, timeout, responsive):
     """Test UI flows and interactions with real-time log monitoring"""
     
     if verbose:
@@ -113,25 +115,59 @@ def test(base_url, path, actions, output, logs, config, verbose, headless, timeo
     
     # Execute test actions
     try:
-        console.print(f"🚀 Executing {len(test_actions)} actions...")
-        results = asyncio.run(flow.execute_and_collect(test_actions))
-        
-        console.print(f"✅ Test completed: {test_description}")
-        console.print(f"📊 Browser events: {len(results.get('browser_events', []))}")
-        console.print(f"📋 Server logs: {len(results.get('server_logs', []))}")
-        console.print(f"📸 Screenshots: {len(results.get('artifacts', {}).get('screenshots', []))}")
-        
-        # Show correlations if found
-        timeline = results.get('organized_timeline', [])
-        if timeline:
-            console.print(f"⏰ Timeline events: {len(timeline)}")
+        if responsive:
+            # Define standard responsive viewports
+            viewports = [
+                {"width": 375, "height": 667, "name": "mobile"},
+                {"width": 768, "height": 1024, "name": "tablet"},
+                {"width": 1440, "height": 900, "name": "desktop"}
+            ]
+            
+            console.print(f"📱 Executing responsive test across {len(viewports)} viewports...")
+            console.print(f"   📱 Mobile: 375x667")
+            console.print(f"   📟 Tablet: 768x1024") 
+            console.print(f"   💻 Desktop: 1440x900")
+            
+            results = asyncio.run(flow.test_responsive(viewports, test_actions))
+            
+            # Display responsive results
+            console.print(f"✅ Responsive test completed: {test_description}")
+            execution_summary = results.get('execution_summary', {})
+            console.print(f"📊 Viewports tested: {execution_summary.get('successful_viewports', 0)}/{execution_summary.get('total_viewports', 0)}")
+            console.print(f"⏱️  Total execution time: {execution_summary.get('execution_time', 0):.2f}s")
+            console.print(f"📸 Screenshots: {len(results.get('artifacts', {}).get('screenshots', []))}")
+            
+            # Show viewport performance
+            responsive_analysis = results.get('responsive_analysis', {})
+            if 'performance_analysis' in responsive_analysis:
+                perf = responsive_analysis['performance_analysis']
+                console.print(f"🏃 Fastest: {perf.get('fastest_viewport')}")
+                console.print(f"🐌 Slowest: {perf.get('slowest_viewport')}")
+        else:
+            console.print(f"🚀 Executing {len(test_actions)} actions...")
+            results = asyncio.run(flow.execute_and_collect(test_actions))
+            
+            console.print(f"✅ Test completed: {test_description}")
+            console.print(f"📊 Browser events: {len(results.get('browser_events', []))}")
+            console.print(f"📋 Server logs: {len(results.get('server_logs', []))}")
+            console.print(f"📸 Screenshots: {len(results.get('artifacts', {}).get('screenshots', []))}")
+            
+            # Show correlations if found
+            timeline = results.get('organized_timeline', [])
+            if timeline:
+                console.print(f"⏰ Timeline events: {len(timeline)}")
         
         # Save results to file for Cursor analysis
         if not output:
-            # Auto-generate meaningful filename
+            # Auto-generate meaningful filename in .cursorflow/artifacts/
             session_id = results.get('session_id', 'unknown')
             path_part = path.replace('/', '_') if path else 'root'
-            output = f"cursorflow_{path_part}_{session_id}.json"
+            
+            # 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"
         
         with open(output, 'w') as f:
             json.dump(results, f, indent=2, default=str)

cursorflow/core/browser_controller.py

@@ -398,24 +398,109 @@ class BrowserController:
             self.logger.error(f"Condition wait failed: {condition}, {e}")
             raise
     
-    async def screenshot(self, name: str, full_page: bool = False, capture_comprehensive_data: bool = True) -> Dict[str, Any]:
-        """Take screenshot with comprehensive page analysis - universal"""
+    async def screenshot(self, name: str, options: Optional[Dict] = None, capture_comprehensive_data: bool = True) -> Dict[str, Any]:
+        """
+        Take screenshot with comprehensive page analysis - universal
+        
+        Args:
+            name: Screenshot name/identifier
+            options: Enhanced screenshot options {
+                "full_page": bool,           # Capture full page (default: False)
+                "clip": {                    # Clip to specific region
+                    "x": int, "y": int,      # Top-left coordinates
+                    "width": int, "height": int
+                } OR {
+                    "selector": str          # Clip to element bounding box
+                },
+                "mask": [str],              # CSS selectors to hide/mask
+                "quality": int              # JPEG quality 0-100 (default: 80)
+            }
+            capture_comprehensive_data: Whether to capture detailed page analysis
+        """
         try:
+            # Process options with defaults
+            screenshot_options = options or {}
+            full_page = screenshot_options.get("full_page", False)
+            clip_config = screenshot_options.get("clip")
+            mask_selectors = screenshot_options.get("mask", [])
+            quality = screenshot_options.get("quality", 80)
+            
             timestamp = int(time.time())
             screenshot_filename = f".cursorflow/artifacts/screenshots/{name}_{timestamp}.png"
             
+            # Apply masking if requested (hide sensitive elements)
+            masked_elements = []
+            if mask_selectors:
+                for selector in mask_selectors:
+                    try:
+                        await self.page.add_style_tag(content=f"""
+                            {selector} {{
+                                visibility: hidden !important;
+                                opacity: 0 !important;
+                            }}
+                        """)
+                        masked_elements.append(selector)
+                        self.logger.debug(f"Masked element: {selector}")
+                    except Exception as e:
+                        self.logger.warning(f"Failed to mask {selector}: {e}")
+            
+            # Prepare screenshot parameters
+            screenshot_params = {
+                "path": screenshot_filename,
+                "full_page": full_page,
+                "quality": quality
+            }
+            
+            # Handle clipping options
+            if clip_config:
+                if "selector" in clip_config:
+                    # Clip to element bounding box
+                    try:
+                        element = await self.page.wait_for_selector(clip_config["selector"], timeout=5000)
+                        if element:
+                            bounding_box = await element.bounding_box()
+                            if bounding_box:
+                                screenshot_params["clip"] = bounding_box
+                                self.logger.debug(f"Clipping to element {clip_config['selector']}: {bounding_box}")
+                            else:
+                                self.logger.warning(f"Element {clip_config['selector']} has no bounding box")
+                        else:
+                            self.logger.warning(f"Element {clip_config['selector']} not found for clipping")
+                    except Exception as e:
+                        self.logger.warning(f"Failed to clip to element {clip_config['selector']}: {e}")
+                
+                elif all(key in clip_config for key in ["x", "y", "width", "height"]):
+                    # Clip to specific coordinates
+                    screenshot_params["clip"] = {
+                        "x": clip_config["x"],
+                        "y": clip_config["y"], 
+                        "width": clip_config["width"],
+                        "height": clip_config["height"]
+                    }
+                    self.logger.debug(f"Clipping to coordinates: {screenshot_params['clip']}")
+            
             # Take the visual screenshot
-            await self.page.screenshot(
-                path=screenshot_filename,
-                full_page=full_page
-            )
+            await self.page.screenshot(**screenshot_params)
+            
+            # Remove masking styles
+            if masked_elements:
+                try:
+                    for selector in masked_elements:
+                        await self.page.add_style_tag(content=f"""
+                            {selector} {{
+                                visibility: visible !important;
+                                opacity: 1 !important;
+                            }}
+                        """)
+                except Exception as e:
+                    self.logger.warning(f"Failed to remove masking: {e}")
             
             # Always return structured data for consistency
             screenshot_data = {
                 "screenshot_path": screenshot_filename,
                 "timestamp": timestamp,
                 "name": name,
-                "full_page": full_page,
+                "options": screenshot_options,
                 "session_id": self.session_id,
                 "trace_info": self.trace_manager.get_trace_info() if self.trace_manager else None
             }
@@ -515,16 +600,32 @@ class BrowserController:
             raise
     
     async def get_performance_metrics(self) -> Dict:
-        """Get page performance metrics - universal"""
+        """Get page performance metrics - universal with proper null handling"""
         try:
             metrics = await self.page.evaluate("""
                 () => {
+                    // Helper function to safely calculate timing differences
+                    const safeTiming = (end, start) => {
+                        if (!end || !start || end === 0 || start === 0) return null;
+                        const diff = end - start;
+                        return diff >= 0 ? diff : null;
+                    };
+                    
                     const perf = performance.getEntriesByType('navigation')[0];
+                    const paint = performance.getEntriesByType('paint');
+                    const lcp = performance.getEntriesByType('largest-contentful-paint')[0];
+                    
                     return {
-                        loadTime: perf ? perf.loadEventEnd - perf.loadEventStart : 0,
-                        domContentLoaded: perf ? perf.domContentLoadedEventEnd - perf.domContentLoadedEventStart : 0,
-                        firstPaint: performance.getEntriesByType('paint').find(p => p.name === 'first-paint')?.startTime || 0,
-                        largestContentfulPaint: performance.getEntriesByType('largest-contentful-paint')[0]?.startTime || 0
+                        loadTime: perf ? safeTiming(perf.loadEventEnd, perf.loadEventStart) : null,
+                        domContentLoaded: perf ? safeTiming(perf.domContentLoadedEventEnd, perf.domContentLoadedEventStart) : null,
+                        firstPaint: paint.find(p => p.name === 'first-paint')?.startTime || null,
+                        largestContentfulPaint: lcp?.startTime || null,
+                        _reliability: {
+                            navigation_available: perf !== undefined,
+                            paint_available: paint.length > 0,
+                            lcp_available: lcp !== undefined,
+                            note: "null values in headless mode are expected"
+                        }
                     };
                 }
             """)
@@ -533,7 +634,7 @@ class BrowserController:
             
         except Exception as e:
             self.logger.error(f"Performance metrics failed: {e}")
-            return {}
+            return {"error": str(e)}
     
     async def cleanup(self):
         """Clean up browser resources and stop trace recording"""

cursorflow/core/browser_engine.py

@@ -340,22 +340,35 @@ class BrowserEngine:
         return validation_result
     
     async def get_performance_metrics(self) -> Dict:
-        """Get browser performance metrics"""
+        """Get browser performance metrics with proper null handling"""
         
         metrics = await self.page.evaluate("""() => {
+            // Helper function to safely calculate timing differences
+            const safeTiming = (end, start) => {
+                if (!end || !start || end === 0 || start === 0) return null;
+                const diff = end - start;
+                return diff >= 0 ? diff : null;
+            };
+            
             const timing = performance.timing;
             const navigation = performance.getEntriesByType('navigation')[0];
             
             return {
-                page_load_time: timing.loadEventEnd - timing.navigationStart,
-                dom_ready_time: timing.domContentLoadedEventEnd - timing.navigationStart,
+                page_load_time: safeTiming(timing.loadEventEnd, timing.navigationStart),
+                dom_ready_time: safeTiming(timing.domContentLoadedEventEnd, timing.navigationStart),
                 first_paint: navigation ? navigation.loadEventEnd : null,
                 resource_count: performance.getEntriesByType('resource').length,
                 memory_usage: performance.memory ? {
                     used: performance.memory.usedJSHeapSize,
                     total: performance.memory.totalJSHeapSize,
                     limit: performance.memory.jsHeapSizeLimit
-                } : null
+                } : null,
+                _reliability: {
+                    timing_available: timing !== undefined,
+                    navigation_available: navigation !== undefined,
+                    memory_available: performance.memory !== undefined,
+                    note: "null values in headless mode are expected"
+                }
             };
         }""")
         

cursorflow/core/cursorflow.py

@@ -716,9 +716,23 @@ class CursorFlow:
                 
             # Capture actions
             elif "screenshot" in action:
-                name = action["screenshot"]
-                screenshot_path = await self.browser.screenshot(name)
-                self.artifacts["screenshots"].append(screenshot_path)
+                screenshot_config = action["screenshot"]
+                
+                # Handle both string and dict formats
+                if isinstance(screenshot_config, str):
+                    # Simple format: {"screenshot": "name"}
+                    name = screenshot_config
+                    options = None
+                elif isinstance(screenshot_config, dict):
+                    # Enhanced format: {"screenshot": {"name": "test", "options": {...}}}
+                    name = screenshot_config.get("name", "screenshot")
+                    options = screenshot_config.get("options")
+                else:
+                    name = "screenshot"
+                    options = None
+                
+                screenshot_data = await self.browser.screenshot(name, options)
+                self.artifacts["screenshots"].append(screenshot_data)
                 
             elif "authenticate" in action:
                 if self.auth_handler:
@@ -750,12 +764,249 @@ class CursorFlow:
         except Exception as e:
             self.logger.error(f"Session cleanup failed: {e}")
     
-    def _recommend_best_iteration(self, iterations: List[Dict]) -> Optional[str]:
-        """Recommend best CSS iteration based on metrics"""
-        if not iterations:
-            return None
+    async def test_responsive(self, viewports: List[Dict], actions: List[Dict], session_options: Optional[Dict] = None) -> Dict[str, Any]:
+        """
+        Test the same actions across multiple viewports in parallel
+        
+        Args:
+            viewports: List of viewport configurations [{"width": 375, "height": 667, "name": "mobile"}, ...]
+            actions: Actions to execute on each viewport
+            session_options: Optional session configuration
+            
+        Returns:
+            Dict with results for each viewport plus comparison analysis
+        """
+        session_options = session_options or {}
+        responsive_session_id = session_options.get("session_id", f"responsive_{int(time.time())}")
+        
+        self.logger.info(f"Starting responsive testing across {len(viewports)} viewports")
+        
+        try:
+            # Execute tests in parallel across all viewports
+            viewport_tasks = []
+            for viewport in viewports:
+                task = self._test_single_viewport(viewport, actions, responsive_session_id)
+                viewport_tasks.append(task)
+            
+            # Wait for all viewport tests to complete
+            viewport_results = await asyncio.gather(*viewport_tasks, return_exceptions=True)
+            
+            # Process results and handle any exceptions
+            processed_results = {}
+            successful_viewports = []
+            failed_viewports = []
+            
+            for i, result in enumerate(viewport_results):
+                viewport_name = viewports[i]["name"]
+                if isinstance(result, Exception):
+                    self.logger.error(f"Viewport {viewport_name} failed: {result}")
+                    failed_viewports.append({"name": viewport_name, "error": str(result)})
+                else:
+                    processed_results[viewport_name] = result
+                    successful_viewports.append(viewport_name)
+            
+            # Create responsive analysis
+            responsive_analysis = self._analyze_responsive_results(processed_results, viewports)
+            
+            return {
+                "session_id": responsive_session_id,
+                "timestamp": time.time(),
+                "viewport_results": processed_results,
+                "responsive_analysis": responsive_analysis,
+                "execution_summary": {
+                    "total_viewports": len(viewports),
+                    "successful_viewports": len(successful_viewports),
+                    "failed_viewports": len(failed_viewports),
+                    "success_rate": len(successful_viewports) / len(viewports),
+                    "execution_time": responsive_analysis.get("total_execution_time", 0)
+                },
+                "failed_viewports": failed_viewports if failed_viewports else None,
+                "artifacts": {
+                    "screenshots": self._collect_responsive_screenshots(processed_results),
+                    "comprehensive_data": self._collect_responsive_data(processed_results)
+                }
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Responsive testing failed: {e}")
+            return {
+                "session_id": responsive_session_id,
+                "error": str(e),
+                "timestamp": time.time()
+            }
+    
+    async def _test_single_viewport(self, viewport: Dict, actions: List[Dict], session_id: str) -> Dict[str, Any]:
+        """Execute test actions for a single viewport"""
+        viewport_name = viewport["name"]
+        viewport_width = viewport["width"]
+        viewport_height = viewport["height"]
+        
+        # Create a separate browser instance for this viewport
+        viewport_browser = BrowserController(
+            base_url=self.base_url,
+            config={
+                **self.browser_config,
+                "viewport": {"width": viewport_width, "height": viewport_height}
+            }
+        )
+        
+        try:
+            # Initialize browser with specific viewport
+            await viewport_browser.initialize()
+            
+            # Set the session ID for artifact organization
+            viewport_browser.session_id = f"{session_id}_{viewport_name}"
+            
+            # Execute all actions for this viewport
+            viewport_artifacts = {"screenshots": [], "comprehensive_data": []}
+            viewport_timeline = []
+            
+            for action in actions:
+                action_start = time.time()
+                
+                # Use the same action handling as execute_and_collect for consistency
+                if "navigate" in action:
+                    await viewport_browser.navigate(action["navigate"])
+                elif "click" in action:
+                    selector = action["click"]
+                    if isinstance(selector, dict):
+                        selector = selector["selector"]
+                    await viewport_browser.click(selector)
+                elif "fill" in action:
+                    fill_config = action["fill"]
+                    await viewport_browser.fill(fill_config["selector"], fill_config["value"])
+                elif "wait_for" in action:
+                    selector = action["wait_for"]
+                    if isinstance(selector, dict):
+                        selector = selector["selector"]
+                    await viewport_browser.wait_for_element(selector)
+                elif "wait" in action:
+                    wait_time = action["wait"] * 1000  # Convert to milliseconds
+                    await viewport_browser.page.wait_for_timeout(wait_time)
+                elif "screenshot" in action:
+                    screenshot_config = action["screenshot"]
+                    
+                    # Handle both string and dict formats
+                    if isinstance(screenshot_config, str):
+                        name = f"{viewport_name}_{screenshot_config}"
+                        options = None
+                    elif isinstance(screenshot_config, dict):
+                        name = f"{viewport_name}_{screenshot_config.get('name', 'screenshot')}"
+                        options = screenshot_config.get("options")
+                    else:
+                        name = f"{viewport_name}_screenshot"
+                        options = None
+                    
+                    screenshot_data = await viewport_browser.screenshot(name, options)
+                    viewport_artifacts["screenshots"].append(screenshot_data)
+                elif "authenticate" in action:
+                    # Note: Auth handler would need to be passed to viewport browser
+                    # For now, log that auth is not supported in responsive mode
+                    self.logger.warning(f"Authentication action skipped in responsive mode for viewport {viewport_name}")
+                else:
+                    # Log unsupported actions
+                    action_type = list(action.keys())[0] if action else "unknown"
+                    self.logger.warning(f"Unsupported action '{action_type}' in responsive mode for viewport {viewport_name}")
+                
+                # Record action in timeline
+                viewport_timeline.append({
+                    "timestamp": action_start,
+                    "type": "browser",
+                    "event": list(action.keys())[0],
+                    "data": action,
+                    "duration": time.time() - action_start,
+                    "viewport": viewport_name
+                })
             
-        # Simple scoring based on lack of console errors and performance
+            return {
+                "viewport": viewport,
+                "artifacts": viewport_artifacts,
+                "timeline": viewport_timeline,
+                "success": True,
+                "execution_time": sum(event["duration"] for event in viewport_timeline)
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Viewport {viewport_name} test failed: {e}")
+            return {
+                "viewport": viewport,
+                "error": str(e),
+                "success": False
+            }
+        finally:
+            await viewport_browser.cleanup()
+    
+    def _analyze_responsive_results(self, results: Dict, viewports: List[Dict]) -> Dict[str, Any]:
+        """Analyze responsive testing results for patterns and insights"""
+        if not results:
+            return {"error": "No successful viewport results to analyze"}
+        
+        analysis = {
+            "viewport_comparison": {},
+            "responsive_insights": [],
+            "performance_analysis": {},
+            "total_execution_time": 0
+        }
+        
+        # Compare viewports
+        viewport_names = list(results.keys())
+        for viewport_name in viewport_names:
+            result = results[viewport_name]
+            viewport_config = next(v for v in viewports if v["name"] == viewport_name)
+            
+            analysis["viewport_comparison"][viewport_name] = {
+                "dimensions": f"{viewport_config['width']}x{viewport_config['height']}",
+                "screenshot_count": len(result.get("artifacts", {}).get("screenshots", [])),
+                "execution_time": result.get("execution_time", 0),
+                "actions_completed": len(result.get("timeline", [])),
+                "success": result.get("success", False)
+            }
+            
+            analysis["total_execution_time"] += result.get("execution_time", 0)
+        
+        # Generate responsive insights
+        if len(viewport_names) >= 2:
+            analysis["responsive_insights"].extend([
+                f"Tested across {len(viewport_names)} viewports: {', '.join(viewport_names)}",
+                f"Total execution time: {analysis['total_execution_time']:.2f}s",
+                f"Average time per viewport: {analysis['total_execution_time'] / len(viewport_names):.2f}s"
+            ])
+            
+            # Performance comparison
+            execution_times = [results[vp].get("execution_time", 0) for vp in viewport_names]
+            fastest_vp = viewport_names[execution_times.index(min(execution_times))]
+            slowest_vp = viewport_names[execution_times.index(max(execution_times))]
+            
+            analysis["performance_analysis"] = {
+                "fastest_viewport": fastest_vp,
+                "slowest_viewport": slowest_vp,
+                "time_difference": max(execution_times) - min(execution_times),
+                "performance_variance": "low" if max(execution_times) - min(execution_times) < 2 else "high"
+            }
+        
+        return analysis
+    
+    def _collect_responsive_screenshots(self, results: Dict) -> List[Dict]:
+        """Collect all screenshots from responsive testing"""
+        all_screenshots = []
+        for viewport_name, result in results.items():
+            if result.get("success") and "artifacts" in result:
+                for screenshot in result["artifacts"].get("screenshots", []):
+                    screenshot["viewport"] = viewport_name
+                    all_screenshots.append(screenshot)
+        return all_screenshots
+    
+    def _collect_responsive_data(self, results: Dict) -> List[Dict]:
+        """Collect all comprehensive data from responsive testing"""
+        all_data = []
+        for viewport_name, result in results.items():
+            if result.get("success") and "artifacts" in result:
+                for data in result["artifacts"].get("comprehensive_data", []):
+                    data["viewport"] = viewport_name
+                    all_data.append(data)
+        return all_data
+    
+    def _recommend_best_iteration(self, iterations: List[Dict]) -> Optional[str]:
         best_iteration = None
         best_score = -1
         

cursorflow/install_cursorflow_rules.py

@@ -125,9 +125,9 @@ def create_config_template(project_path: Path, force: bool = False):
     # Get current version
     try:
         import cursorflow
-        current_version = getattr(cursorflow, '__version__', '2.0.3')
+        current_version = getattr(cursorflow, '__version__', '2.1.0')
     except ImportError:
-        current_version = '2.0.3'
+        current_version = '2.1.0'
     
     if config_path.exists():
         if not force:
@@ -302,9 +302,9 @@ def setup_update_checking(project_path: Path):
     # Create initial version tracking
     try:
         import cursorflow
-        current_version = getattr(cursorflow, '__version__', '2.0.3')
+        current_version = getattr(cursorflow, '__version__', '2.1.0')
     except ImportError:
-        current_version = '2.0.3'
+        current_version = '2.1.0'
     
     version_info = {
         "installed_version": current_version,