cursorflow 1.3.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

cursorflow/core/trace_manager.py

@@ -0,0 +1,209 @@
+"""
+Trace Manager for CursorFlow v2.0
+
+Manages Playwright trace file recording for complete interaction history.
+Pure observation - records everything without modifying application behavior.
+"""
+
+import asyncio
+import time
+import logging
+from typing import Optional, Dict, Any
+from pathlib import Path
+from playwright.async_api import BrowserContext
+
+
+class TraceManager:
+    """
+    Manages Playwright trace recording for comprehensive debugging data
+    
+    Provides complete interaction history, screenshots, and network activity
+    in Playwright's native trace format for maximum debugging capability.
+    """
+    
+    def __init__(self, artifacts_base: Path):
+        """
+        Initialize trace manager
+        
+        Args:
+            artifacts_base: Base directory for storing trace files
+        """
+        self.artifacts_base = artifacts_base
+        self.traces_dir = artifacts_base / "traces"
+        self.traces_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.current_trace_path: Optional[Path] = None
+        self.is_recording = False
+        self.session_id: Optional[str] = None
+        
+        self.logger = logging.getLogger(__name__)
+    
+    async def start_trace(self, context: BrowserContext, session_id: str) -> str:
+        """
+        Start Playwright trace recording
+        
+        Args:
+            context: Browser context to record
+            session_id: Unique session identifier
+            
+        Returns:
+            Path where trace will be saved
+        """
+        try:
+            self.session_id = session_id
+            self.current_trace_path = self.traces_dir / f"{session_id}.zip"
+            
+            # Start comprehensive trace recording
+            await context.tracing.start(
+                screenshots=True,      # Capture screenshots at each action
+                snapshots=True,        # Capture DOM snapshots
+                sources=True,          # Include source code context
+                title=f"CursorFlow Session {session_id}"
+            )
+            
+            self.is_recording = True
+            self.logger.info(f"Started trace recording: {self.current_trace_path}")
+            
+            return str(self.current_trace_path)
+            
+        except Exception as e:
+            self.logger.error(f"Failed to start trace recording: {e}")
+            self.is_recording = False
+            raise
+    
+    async def stop_trace(self, context: BrowserContext) -> Optional[str]:
+        """
+        Stop trace recording and save file
+        
+        Args:
+            context: Browser context being recorded
+            
+        Returns:
+            Path to saved trace file, or None if recording wasn't active
+        """
+        if not self.is_recording or not self.current_trace_path:
+            return None
+        
+        try:
+            await context.tracing.stop(path=str(self.current_trace_path))
+            
+            trace_path = str(self.current_trace_path)
+            file_size = self.current_trace_path.stat().st_size if self.current_trace_path.exists() else 0
+            
+            self.logger.info(f"Trace recording saved: {trace_path} ({file_size:,} bytes)")
+            
+            # Reset state
+            self.is_recording = False
+            self.current_trace_path = None
+            self.session_id = None
+            
+            return trace_path
+            
+        except Exception as e:
+            self.logger.error(f"Failed to stop trace recording: {e}")
+            self.is_recording = False
+            return None
+    
+    async def stop_trace_on_error(self, context: BrowserContext, error: Exception) -> Optional[str]:
+        """
+        Stop trace recording when an error occurs, with error context
+        
+        Args:
+            context: Browser context being recorded
+            error: The error that occurred
+            
+        Returns:
+            Path to saved trace file with error context
+        """
+        if not self.is_recording or not self.current_trace_path:
+            return None
+        
+        try:
+            # Add error context to trace filename
+            error_trace_path = self.traces_dir / f"{self.session_id}_ERROR_{type(error).__name__}.zip"
+            
+            await context.tracing.stop(path=str(error_trace_path))
+            
+            file_size = error_trace_path.stat().st_size if error_trace_path.exists() else 0
+            
+            self.logger.info(f"Error trace saved: {error_trace_path} ({file_size:,} bytes)")
+            self.logger.info(f"View trace: playwright show-trace {error_trace_path}")
+            
+            # Reset state
+            self.is_recording = False
+            self.current_trace_path = None
+            self.session_id = None
+            
+            return str(error_trace_path)
+            
+        except Exception as trace_error:
+            self.logger.error(f"Failed to save error trace: {trace_error}")
+            self.is_recording = False
+            return None
+    
+    def get_trace_info(self) -> Dict[str, Any]:
+        """
+        Get current trace recording information
+        
+        Returns:
+            Dictionary with trace status and metadata
+        """
+        return {
+            "is_recording": self.is_recording,
+            "session_id": self.session_id,
+            "trace_path": str(self.current_trace_path) if self.current_trace_path else None,
+            "traces_directory": str(self.traces_dir),
+            "total_traces": len(list(self.traces_dir.glob("*.zip")))
+        }
+    
+    def cleanup_old_traces(self, max_traces: int = 50) -> int:
+        """
+        Clean up old trace files to prevent disk space issues
+        
+        Args:
+            max_traces: Maximum number of trace files to keep
+            
+        Returns:
+            Number of traces deleted
+        """
+        try:
+            trace_files = sorted(
+                self.traces_dir.glob("*.zip"),
+                key=lambda p: p.stat().st_mtime,
+                reverse=True  # Newest first
+            )
+            
+            if len(trace_files) <= max_traces:
+                return 0
+            
+            # Delete oldest traces
+            traces_to_delete = trace_files[max_traces:]
+            deleted_count = 0
+            
+            for trace_file in traces_to_delete:
+                try:
+                    trace_file.unlink()
+                    deleted_count += 1
+                except Exception as e:
+                    self.logger.warning(f"Failed to delete old trace {trace_file}: {e}")
+            
+            if deleted_count > 0:
+                self.logger.info(f"Cleaned up {deleted_count} old trace files")
+            
+            return deleted_count
+            
+        except Exception as e:
+            self.logger.error(f"Trace cleanup failed: {e}")
+            return 0
+    
+    def get_viewing_instructions(self, trace_path: str) -> str:
+        """
+        Get instructions for viewing a trace file
+        
+        Args:
+            trace_path: Path to the trace file
+            
+        Returns:
+            Command to view the trace
+        """
+        return f"playwright show-trace {trace_path}"

cursorflow/log_sources/local_file.py

@@ -98,7 +98,11 @@ class LocalFileLogSource:
             return True
             
         except Exception as e:
-            self.logger.error(f"Failed to start tail for {log_name}: {e}")
+            # Log as debug instead of error for non-critical issues
+            if "No such file or directory" in str(e) or "Permission denied" in str(e):
+                self.logger.debug(f"Non-critical log file issue for {log_name}: {e}")
+            else:
+                self.logger.error(f"Failed to start tail for {log_name}: {e}")
             return False
     
     def _read_tail_output(self, log_name: str, log_path: str, process: subprocess.Popen):

cursorflow/log_sources/ssh_remote.py

@@ -10,8 +10,9 @@ import threading
 import queue
 import time
 import logging
+import re
 from typing import Dict, List, Optional
-from datetime import datetime
+from datetime import datetime, timedelta
 
 class SSHRemoteLogSource:
     """Remote log monitoring via SSH"""
@@ -89,7 +90,11 @@ class SSHRemoteLogSource:
             return result == 'test'
             
         except Exception as e:
-            self.logger.error(f"SSH connection test failed: {e}")
+            # Log SSH connection issues as debug for non-critical cases
+            if "Connection refused" in str(e) or "timeout" in str(e).lower():
+                self.logger.debug(f"SSH connection issue (may be expected): {e}")
+            else:
+                self.logger.error(f"SSH connection test failed: {e}")
             return False
     
     def _monitor_single_log(self, log_name: str, log_path: str):

cursorflow-2.0.0.dist-info/METADATA

@@ -0,0 +1,293 @@
+Metadata-Version: 2.4
+Name: cursorflow
+Version: 2.0.0
+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
+Project-URL: Homepage, https://github.com/haley-marketing-group/cursorflow
+Project-URL: Documentation, https://cursorflow.readthedocs.io
+Project-URL: Repository, https://github.com/haley-marketing-group/cursorflow
+Keywords: ui-testing,automation,cursor,ai,web-testing,css-iteration,hot-reload,hmr,element-intelligence,page-analysis,error-context
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: playwright>=1.40.0
+Requires-Dist: paramiko>=3.3.1
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: asyncio-mqtt>=0.11.1
+Requires-Dist: click>=8.1.7
+Requires-Dist: rich>=13.6.0
+Requires-Dist: jinja2>=3.1.2
+Requires-Dist: python-dateutil>=2.8.2
+Requires-Dist: watchdog>=3.0.0
+Requires-Dist: docker>=6.1.3
+Requires-Dist: pillow>=10.0.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: websockets>=11.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.1; extra == "dev"
+Requires-Dist: black>=23.9.1; extra == "dev"
+Requires-Dist: flake8>=6.1.0; extra == "dev"
+Requires-Dist: mypy>=1.6.1; extra == "dev"
+Dynamic: license-file
+
+# CursorFlow
+
+**Complete page intelligence for AI-driven development**
+
+CursorFlow captures comprehensive data from web applications - DOM structure, CSS properties, network activity, console logs, and performance metrics - enabling AI agents like Cursor to make intelligent decisions about UI improvements and debugging.
+
+## 🎯 What CursorFlow Does
+
+**Data Collection, Not Analysis** - We gather structured data, AI makes the decisions.
+
+### **📊 Complete Page Intelligence**
+Every screenshot captures everything:
+- **DOM**: All elements with 7 selector strategies each
+- **Network**: All requests, responses, and complete response bodies
+- **Console**: All logs, errors, and smart error correlation
+- **Performance**: Load times, memory usage, with reliability indicators
+- **Visual**: Screenshots with pixel-perfect comparisons
+- **Fonts**: Loading status, performance, and usage analysis
+- **Animations**: Active animations and transitions tracking
+- **Resources**: Complete resource loading analysis
+- **Storage**: localStorage, sessionStorage, cookies, IndexedDB state
+
+### **🔄 Rapid Iteration Support**
+- **Hot Reload Intelligence** with framework auto-detection (Vite, Webpack, Next.js, Parcel, Laravel Mix)
+- **Mockup comparison** with enhanced DOM and CSS analysis
+- **Hot reload integration** for instant, perfectly-timed CSS testing
+- **Persistent sessions** that survive code changes
+- **Universal framework support** (React, Vue, PHP, Perl, anything)
+
+### **🤖 AI-First Design**
+All data structured for AI consumption:
+- Consistent JSON format across all features
+- **Multi-selector element identification** for robust automation
+- **Accessibility-aware** element analysis
+- Error correlation with **smart screenshot deduplication**
+- Performance insights with **reliability metadata**
+- **HMR event correlation** for CSS change tracking
+
+## 🚀 Quick Start
+
+```bash
+# Install CursorFlow
+pip install cursorflow
+
+# Test with complete intelligence
+cursorflow test --base-url http://localhost:3000 --actions '[
+  {"navigate": "/dashboard"},
+  {"wait_for": "#main-content"},
+  {"screenshot": "dashboard-loaded"}
+]'
+
+# HMR-powered CSS iteration
+cursorflow iterate-mockup https://mockup.com/design \
+  --base-url http://localhost:5173 \
+  --css-improvements '[
+    {"name": "fix-spacing", "css": ".container { gap: 2rem; }"}
+  ]'
+```
+
+## 💻 Usage Examples
+
+### **Hot Reload Intelligence**
+```python
+from cursorflow import CursorFlow
+
+async def hmr_workflow():
+    flow = CursorFlow("http://localhost:5173", {"headless": False})
+    
+    # Start HMR monitoring (auto-detects Vite/Webpack/Next.js)
+    await flow.browser.start_hmr_monitoring()
+    
+    # Take baseline
+    await flow.execute_and_collect([
+        {"navigate": "/app"},
+        {"screenshot": "baseline"}
+    ])
+    
+    # Wait for CSS changes with perfect timing
+    hmr_event = await flow.browser.wait_for_css_update()
+    print(f"🔥 {hmr_event['framework']} CSS update detected!")
+    
+    # Capture immediately after change
+    await flow.execute_and_collect([
+        {"screenshot": "updated"}
+    ])
+```
+
+### **Advanced Element Analysis**
+```python
+# Get comprehensive element data
+results = await flow.execute_and_collect([
+    {"navigate": "/form"},
+    {"screenshot": "form-analysis"}
+])
+
+# Access enhanced element data
+for element in results['artifacts']['screenshots'][0]['dom_analysis']['elements']:
+    print(f"Element: {element['selector']}")
+    print(f"  7 Selectors: {list(element['selectors'].keys())}")
+    print(f"  Accessible: {element['accessibility']['role']}")
+    print(f"  Interactive: {element['accessibility']['interactive']}")
+    print(f"  Visible: {element['visual_context']['visibility']['is_visible']}")
+```
+
+### **Comprehensive Page Intelligence**
+```python
+# Get complete page analysis
+screenshot = results['artifacts']['screenshots'][0]
+
+# Complete Intelligence
+print(f"Fonts loaded: {screenshot['font_status']['loadedFonts']}")
+print(f"Animations running: {screenshot['animation_status']['runningAnimations']}")  
+print(f"Resources: {screenshot['resource_status']['totalResources']}")
+print(f"Storage items: {screenshot['storage_status']['localStorage']['itemCount']}")
+```
+
+### **Smart Error Diagnostics**
+```python
+# Enhanced error context with deduplication
+error_context = await flow.browser.capture_interaction_error_context(
+    action_description="Submit form",
+    error_details={"type": "validation_error"}
+)
+
+print(f"Screenshot: {error_context['screenshot_info']['path']}")
+print(f"Reused: {error_context['screenshot_info']['is_reused']}")  # Smart deduplication
+print(f"Context: {len(error_context['recent_actions'])} recent actions")
+```
+
+## 🔧 CLI Commands
+
+### **Universal Testing with Complete Intelligence**
+```bash
+# Simple page test with full intelligence
+cursorflow test --base-url http://localhost:3000 --path "/dashboard"
+
+# Complex interaction test
+cursorflow test --base-url http://localhost:3000 --actions '[
+  {"navigate": "/login"},
+  {"fill": {"selector": "#email", "value": "test@example.com"}},
+  {"click": "#login-btn"},
+  {"wait_for": ".dashboard"},
+  {"screenshot": "logged-in"}
+]'
+```
+
+### **HMR-Powered CSS Iteration**
+```bash
+# Perfect CSS iteration with HMR intelligence
+cursorflow iterate-mockup https://mockup.com/design \
+  --base-url http://localhost:5173 \
+  --css-improvements '[
+    {"name": "improve-spacing", "css": ".container { gap: 2rem; }"},
+    {"name": "enhance-colors", "css": ".button { background: #007bff; }"}
+  ]'
+```
+
+### **Enhanced Design Comparison**
+```bash
+# Compare with comprehensive intelligence
+cursorflow compare-mockup https://mockup.com/design \
+  --base-url http://localhost:3000 \
+  --mockup-actions '[{"navigate": "/"}]' \
+  --implementation-actions '[{"navigate": "/dashboard"}]'
+```
+
+## 🧠 AI Integration
+
+### **Cursor Rules (Auto-Install)**
+```bash
+# Install AI assistance rules
+cursorflow install-rules
+```
+
+CursorFlow includes comprehensive rules that teach Cursor:
+- **When to use HMR intelligence** for CSS iteration
+- **How to analyze multi-selector element data**
+- **Best practices for comprehensive page analysis**
+- **Error debugging with smart context collection**
+
+### **Structured Data for AI**
+Every CursorFlow operation returns **perfectly structured JSON** optimized for AI analysis:
+
+```json
+{
+  "artifacts": {
+    "screenshots": [{
+      "path": ".cursorflow/artifacts/screenshots/dashboard_123.png",
+      "dom_analysis": {
+        "elements": [...],  // 7 selectors + accessibility per element
+        "pageStructure": {...},  // Enhanced page analysis
+        "analysisVersion": "2.0"  // Version tracking
+      },
+      "font_status": {...},      // Font loading intelligence
+      "animation_status": {...}, // Animation tracking
+      "resource_status": {...},  // Resource analysis
+      "storage_status": {...},   // Storage state
+      "hmr_status": {...}        // HMR event data
+    }]
+  }
+}
+```
+
+## 🌟 Framework Support
+
+**HMR Auto-Detection:**
+- ✅ **Vite** (port 5173, WebSocket `/__vite_hmr`)
+- ✅ **Webpack Dev Server** (port 3000, WebSocket `/sockjs-node`)
+- ✅ **Next.js** (port 3000, WebSocket `/_next/webpack-hmr`)
+- ✅ **Parcel** (port 1234, WebSocket `/hmr`)
+- ✅ **Laravel Mix** (port 3000, WebSocket `/browser-sync/socket.io`)
+
+**Universal Compatibility:**
+- Works with **any web application** regardless of framework
+- **Framework-agnostic** core operations
+- **Smart adaptation** to different development environments
+
+## 📖 Documentation
+
+- **[Complete User Manual](docs/USER_MANUAL.md)** - Full feature guide
+- **[Examples](examples/)** - Practical usage examples
+- **[API Reference](docs/api/)** - Complete Python API documentation
+
+## 🚀 Why CursorFlow?
+
+### **For Developers:**
+- **Faster CSS iteration** with HMR precision timing
+- **Complete element intelligence** with multi-selector strategies
+- **Full page visibility** with comprehensive analysis
+- **Smart error debugging** with rich context collection
+
+### **For AI Agents:**
+- **Perfect structured data** for intelligent decision making
+- **Multi-selector reliability** for robust automation
+- **Accessibility awareness** for inclusive development
+- **HMR correlation** for understanding change impact
+
+### **For Teams:**
+- **Framework agnostic** - works with any web technology
+- **Production ready** - handles real-world complexity
+- **Comprehensive testing** - covers all aspects of web apps
+- **AI-first design** - built for autonomous development
+
+---
+
+**Complete page intelligence for AI-driven development with CursorFlow**
+
+*Hot reload precision • Advanced element analysis • Smart error diagnostics • Comprehensive page intelligence*

{cursorflow-1.3.6.dist-info → cursorflow-2.0.0.dist-info}/RECORD

@@ -5,27 +5,30 @@ cursorflow/install_cursorflow_rules.py,sha256=ny4c-S1O-V2sITunZO2kk6sCf1yec42UJO
 cursorflow/updater.py,sha256=pvbSZgg6hgWZBE5AAUPppS5Yzv0yNMp2X_CL2GALg_w,18783
 cursorflow/core/agent.py,sha256=f3lecgEzDRDdGTVccAtorpLGfNJJ49bbsQAmgr0vNGg,10136
 cursorflow/core/auth_handler.py,sha256=oRafO6ZdxoHryBIvHsrNV8TECed4GXpJsdEiH0KdPPk,17149
-cursorflow/core/browser_controller.py,sha256=eHYdWGTWSlssFjTdhq-msPLwg_LMtGF7om2wQZBaJ4A,57196
+cursorflow/core/browser_controller.py,sha256=OII52LBgN97-G-6mPCiqbFGbHnU9KtHaYB0qeylqo2U,125963
 cursorflow/core/browser_engine.py,sha256=Glq8U_bXRkO2Yal0nku7Z2wKwOftY4So2XN4oy56WLo,13732
 cursorflow/core/css_iterator.py,sha256=whLCIwbHZEWaH1HCbmqhNX5zrh_fL-r3hsxKjYsukcE,16478
 cursorflow/core/cursor_integration.py,sha256=MAeHjXYeqzaXnhskqkTDB-n5ixIHqapGe93X0lLKhws,67501
 cursorflow/core/cursorflow.py,sha256=GohWXvCLTsIIxI2UBRkFPM3yptbPNw4wI1vxKRPPMd0,31816
+cursorflow/core/error_context_collector.py,sha256=so-aveqwb6_vRDbtKR2ln8_F84aaVIceNi1UHsaVPgc,26196
 cursorflow/core/error_correlator.py,sha256=g6YaIF2yFXUDrTuWHCyuES6K0696H8LDWmXH1qI8ddA,13367
 cursorflow/core/event_correlator.py,sha256=lCzXFnii17AQt3rOVOclez_AnjvBCF_2ZlnFG0mIN6c,7808
 cursorflow/core/file_change_monitor.py,sha256=tl_ZdsGW8LZBTImniD-lqaGgNb9dYjlDsP2XmevE0xk,21258
+cursorflow/core/hmr_detector.py,sha256=IrGYhXIeTBukffRXF74SW45cB_Im0cmq8RxxjtSz-2w,17431
 cursorflow/core/log_collector.py,sha256=vZ2Slm6C_OOi68xROWpXPSZqzzQAWK0sk5xEybGlA4w,14217
 cursorflow/core/log_monitor.py,sha256=pONMu_JHEnT0T62OA5KRZ4nClzKgNpifPyrfN5w_RM8,6704
-cursorflow/core/mockup_comparator.py,sha256=QBcUrqERsAizklTbQmaohtSpa9r9xdgHkAjdkqHyTtk,63754
+cursorflow/core/mockup_comparator.py,sha256=VLfEEaTgbcY0oTb-bhBD2uTbXGjbnOV7LXNVvXpWMrM,64695
 cursorflow/core/persistent_session.py,sha256=FsEHj4wKkycmdp6PFRHv3g333Y74yqra0x_qhUTQpik,36075
 cursorflow/core/report_generator.py,sha256=-vosfyrnfVyWDbAIMlMurl90xOXqBae8d6aLd9sEqiY,10113
-cursorflow/log_sources/local_file.py,sha256=qA1JWFpoDTsSNM7rA5jMVGF5IPRDWMDjxji6XlgmJbE,6838
-cursorflow/log_sources/ssh_remote.py,sha256=cWH-0ulDilh5kSih8BEzDlY0xU0KASDoq9rPhZN9zqg,7207
+cursorflow/core/trace_manager.py,sha256=Jj9ultZrL1atiZXfcRVI6ynCnnfqZM-X0_taxt-llJ0,7189
+cursorflow/log_sources/local_file.py,sha256=Hn3hDQjAqgNBQN8b5AbC6IQAzgY_ekLgePwDuq9wBlA,7101
+cursorflow/log_sources/ssh_remote.py,sha256=zSnX8mpa5G86UDWEm3_FqYwo1PjBW67C1LPkJ5Ta_ho,7482
 cursorflow/rules/__init__.py,sha256=gPcA-IkhXj03sl7cvZV0wwo7CtEkcyuKs4y0F5oQbqE,458
 cursorflow/rules/cursorflow-installation.mdc,sha256=Nnu7PuP5nGD6hGAV_x2SX5Y2_uPz3oNA5XUjNJBFC1M,6985
 cursorflow/rules/cursorflow-usage.mdc,sha256=Zv0TWuo7S3iJHq8R6oBaHRI3V6h-T81pdb7vi-b8NoU,14157
-cursorflow-1.3.6.dist-info/licenses/LICENSE,sha256=e4QbjAsj3bW-xgQOvQelr8sGLYDoqc48k6cKgCr_pBU,1080
-cursorflow-1.3.6.dist-info/METADATA,sha256=2T_rJo1JFYQ_j-wFL3_oQxIG8NX_UrUxbMiyrOaF20I,7657
-cursorflow-1.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cursorflow-1.3.6.dist-info/entry_points.txt,sha256=-Ed_n4Uff7wClEtWS-Py6xmQabecB9f0QAOjX0w7ljA,51
-cursorflow-1.3.6.dist-info/top_level.txt,sha256=t1UZwRyZP4u-ng2CEcNHmk_ZT4ibQxoihB2IjTF7ovc,11
-cursorflow-1.3.6.dist-info/RECORD,,
+cursorflow-2.0.0.dist-info/licenses/LICENSE,sha256=e4QbjAsj3bW-xgQOvQelr8sGLYDoqc48k6cKgCr_pBU,1080
+cursorflow-2.0.0.dist-info/METADATA,sha256=umhLvqBVKOkvvJ0as3gfKDGmd-KW2POSW8c1nHovBAk,10656
+cursorflow-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cursorflow-2.0.0.dist-info/entry_points.txt,sha256=-Ed_n4Uff7wClEtWS-Py6xmQabecB9f0QAOjX0w7ljA,51
+cursorflow-2.0.0.dist-info/top_level.txt,sha256=t1UZwRyZP4u-ng2CEcNHmk_ZT4ibQxoihB2IjTF7ovc,11
+cursorflow-2.0.0.dist-info/RECORD,,