docs: add rules for cursor, kiro, windsurf

.cursor/rules/python-style.mdc

@@ -0,0 +1,150 @@
+---
+alwaysApply: true
+---
+
+# Python Code Style Rules
+
+## Formatting Standards
+
+### Ruff Configuration Compliance
+- Use 88 character line length limit
+- Use 4 spaces for indentation (never tabs)
+- Use double quotes for strings consistently
+- Target Python 3.11+ features and syntax
+- Enable automatic import sorting and organization
+
+### Import Organization
+```python
+# Standard library imports first
+import asyncio
+import logging
+from pathlib import Path
+
+# Third-party imports second
+import aiohttp
+from solana.rpc.async_api import AsyncClient
+
+# Local imports last
+from config_loader import load_bot_config
+from utils.logger import get_logger
+```
+
+### Type Annotations
+- Add type hints to ALL public functions and methods
+- Use modern typing syntax (Python 3.9+ union syntax where applicable)
+- Include return type annotations
+- Use `from typing import Any` for complex types
+
+```python
+def process_transaction(tx_data: dict[str, Any]) -> bool:
+    """Process transaction data and return success status."""
+    pass
+
+async def fetch_data(endpoint: str) -> dict[str, Any] | None:
+    """Fetch data from endpoint, return None on failure."""
+    pass
+```
+
+## Documentation Standards
+
+### Docstring Format
+Use Google-style docstrings for all functions and classes:
+
+```python
+def calculate_slippage(amount: float, slippage_percent: float) -> float:
+    """Calculate slippage amount for a trade.
+    
+    Args:
+        amount: The trade amount in SOL
+        slippage_percent: Slippage percentage (0.1 = 10%)
+        
+    Returns:
+        The calculated slippage amount
+        
+    Raises:
+        ValueError: If slippage_percent is negative
+    """
+    if slippage_percent < 0:
+        raise ValueError("Slippage percentage cannot be negative")
+    return amount * slippage_percent
+```
+
+## Error Handling
+
+### Comprehensive Exception Handling
+- Use try-catch blocks for all external operations (RPC calls, file I/O)
+- Log exceptions with context using `logging.exception()`
+- Provide meaningful error messages
+- Don't suppress exceptions without good reason
+
+```python
+try:
+    result = await client.get_account_info(address)
+    logger.info(f"Successfully fetched account info for {address}")
+except Exception as e:
+    logger.exception(f"Failed to fetch account info for {address}: {e}")
+    raise
+```
+
+## Logging Standards
+
+### Logger Usage
+- Use `get_logger(__name__)` pattern consistently
+- Import from `utils.logger`
+- Use appropriate log levels (DEBUG, INFO, WARNING, ERROR)
+- Include context in log messages
+
+```python
+from utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+# Good logging examples
+logger.info(f"Starting bot '{bot_name}' with platform {platform.value}")
+logger.warning(f"Transaction failed, attempt {attempt}/{max_attempts}")
+logger.error(f"Platform {platform.value} is not supported")
+```
+
+## Security Rules
+
+### Sensitive Data
+- NEVER hardcode private keys, API tokens, or secrets
+- Use environment variables for all sensitive configuration
+- Don't log sensitive information
+- Validate all external inputs
+
+### Safe Practices
+```python
+# Good - using environment variables
+private_key = os.getenv("SOLANA_PRIVATE_KEY")
+if not private_key:
+    raise ValueError("SOLANA_PRIVATE_KEY environment variable is required")
+
+# Bad - hardcoded secrets
+private_key = "your_secret_key_here"  # NEVER DO THIS
+```
+
+## Code Quality
+
+### Linting Compliance
+Ensure code passes all enabled Ruff rules:
+- Security best practices (S)
+- Type annotations (ANN)
+- Exception handling (BLE, TRY)
+- Code complexity (C90)
+- Pylint conventions (PL)
+- No commented-out code (ERA)
+
+### Performance Considerations
+- Use async/await for I/O operations
+- Implement proper connection pooling for HTTP clients
+- Cache expensive computations when appropriate
+- Use uvloop for better async performance
+
+```python
+# Set uvloop policy at module level
+import asyncio
+import uvloop
+
+asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+```