vibetrading-code-gen

What this skill does

# VibeTrading Code Generator

Generate executable Hyperliquid trading strategy code from natural language prompts. This skill transforms trading ideas into ready-to-run Python code using actual Hyperliquid API implementations. Generated code includes complete API integration, error handling, logging, and configuration management.

## Quick Start

### Basic Usage

```bash
# Generate a simple RSI strategy
python scripts/strategy_generator.py "Generate a BTC RSI strategy, buy below 30, sell above 70"

# Generate a grid trading strategy
python scripts/strategy_generator.py "BTC grid trading 50000-60000 10 grids 0.01 BTC per grid"

# Generate a signal-following strategy
python scripts/strategy_generator.py "ETH trading strategy based on VibeTrading signals, buy on bullish signals, sell on bearish signals"
```

### Output Structure

The generator creates:
1. **Strategy Python file** - Complete trading strategy class
2. **Configuration file** - Strategy parameters and settings
3. **Usage instructions** - How to run and monitor the strategy
4. **Requirements file** - Python dependencies

## Code Validation System

### Automatic Code Validation

All generated code is automatically validated and fixed using the built-in validation system:

```bash
# Validate generated code
python scripts/code_validator.py generated_strategy.py

# Validate and fix automatically
python scripts/code_validator.py generated_strategy.py --fix

# Validate entire directory
python scripts/code_validator.py strategy_directory/
```

### Validation Steps

The validation system performs these checks:

1. **Syntax Validation** - Python syntax checking
2. **Import Validation** - Module import verification
3. **Compatibility Checks** - Python 3.5+ compatibility
4. **Common Issue Detection** - Missing imports, encoding issues, etc.

### Automatic Fixes

When validation fails, the system automatically fixes common issues:

1. **Add missing imports** - Add typing imports if type annotations are used
2. **Fix encoding declaration** - Add `# -*- coding: utf-8 -*-` if missing
3. **Remove incompatible syntax** - Remove f-strings and type annotations for Python 3.5 compatibility
4. **Fix import paths** - Add sys.path modifications for API wrappers
5. **Fix logger initialization order** - Ensure logger is initialized before API client
6. **Remove pathlib usage** - Replace with os.path for Python 3.4 compatibility
7. **Fix string formatting** - Convert f-strings to .format() method

### Validation Configuration

The validation system can be configured via command-line arguments:

```bash
# Basic validation
python scripts/code_validator.py strategy.py

# Validate and fix automatically
python scripts/code_validator.py strategy.py --fix

# Use specific Python executable
python scripts/code_validator.py strategy.py --python python3.6

# Validate directory with all files
python scripts/code_validator.py strategies/ --fix

# Maximum 5 fix iterations
python scripts/code_validator.py strategy.py --fix --max-iterations 5
```

### Validation Rules

The system enforces these rules for generated code:

1. **Python 3.5+ Compatibility**
   - No f-strings (use `.format()` or `%` formatting)
   - No type annotations (remove or use comments)
   - No pathlib (use `os.path` instead)
   - No typing module imports

2. **Code Quality**
   - Proper encoding declaration (`# -*- coding: utf-8 -*-`)
   - Logger initialized before API client
   - All imports are resolvable
   - No syntax errors

3. **Security**
   - API keys loaded from environment variables
   - No hardcoded credentials
   - Proper error handling for API calls

4. **Performance**
   - Reasonable check intervals (not too frequent)
   - Efficient data fetching
   - Proper resource cleanup

### Validation Workflow

```
User Prompt → Code Generation → Validation → Fixes → Final Code
                    ↓
              If validation fails
                    ↓
            Apply automatic fixes
                    ↓
          Re-validate until success
                    ↓
          Deliver validated code
```

### Validation Failure Handling

When validation fails, the system automatically updates the code with these steps:

1. **Error Analysis** - Identify the specific validation errors
2. **Fix Application** - Apply appropriate fixes based on error type
3. **Re-validation** - Validate again after fixes
4. **Iterative Repair** - Repeat until code is valid (max 3 iterations)
5. **Fallback Strategy** - If automatic fixes fail, provide detailed error report and manual fix instructions

### Automatic Fix Examples

#### Fix 1: Missing Imports
```python
# Before (error: NameError: name 'List' is not defined)
def calculate_prices(prices: List[float]) -> List[float]:

# After (automatic fix)
from typing import List, Dict, Optional
def calculate_prices(prices):
```

#### Fix 2: Encoding Issues
```python
# Before (error: SyntaxError: Non-ASCII character)
# Strategy description: Grid trading

# After (automatic fix)
# -*- coding: utf-8 -*-
# Strategy description: Grid trading
```

#### Fix 3: Python 3.5 Incompatibility
```python
# Before (error: SyntaxError in Python 3.5)
price = f"Current price: {current_price}"

# After (automatic fix)
price = "Current price: {}".format(current_price)
```

#### Fix 4: Import Path Issues
```python
# Before (error: ImportError: No module named 'hyperliquid_api')
from hyperliquid_api import HyperliquidClient

# After (automatic fix)
import sys
import os
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "api_wrappers"))
from hyperliquid_api import HyperliquidClient
```

## Supported Strategy Types

### 1. Technical Indicator Strategies
- **RSI-based**: Oversold/overbought trading
- **MACD-based**: Trend following with MACD crossovers
- **Moving Average**: SMA/EMA cross strategies
- **Bollinger Bands**: Mean reversion strategies

### 2. Advanced Trading Strategies
- **Grid Trading**: Price range trading with multiple orders
- **Mean Reversion**: Statistical arbitrage strategies
- **Trend Following**: Momentum-based strategies
- **Arbitrage**: Spot-perp or cross-exchange arbitrage

### 3. Signal-Driven Strategies
- **VibeTrading Integration**: Follow AI-generated trading signals
- **News-based**: React to market news and sentiment
- **Whale Activity**: Track large wallet movements
- **Funding Rate**: Funding rate arbitrage strategies

## How It Works

### Step 1: Prompt Analysis
The generator analyzes your natural language prompt to identify:
- Trading symbol (BTC, ETH, SOL, etc.)
- Strategy type (grid, RSI, signal-based, etc.)
- Key parameters (price ranges, grid counts, indicator values)
- Risk management preferences

### Step 2: Template Selection
Based on the analysis, the system selects the most appropriate template from:
- `templates/grid_trading.py` - Grid trading strategy template

### Step 3: Code Generation
The generator:
1. Fills template parameters with your values
2. Adds proper error handling and logging
3. Includes configuration management
4. Generates complete runnable code

### Step 4: Code Validation
The generated code is automatically validated and fixed:
1. **Syntax checking** - Ensure valid Python syntax
2. **Import verification** - Check all imports are resolvable
3. **Compatibility testing** - Verify Python 3.5+ compatibility
4. **Automatic fixes** - Apply fixes for common issues
5. **Re-validation** - Validate again after fixes
6. **Error reporting** - If fixes fail, provide detailed error report

### Validation Failure Handling
If validation fails after automatic fixes:
1. **Error Analysis Report** - Detailed breakdown of remaining issues
2. **Manual Fix Instructions** - Step-by-step guidance for manual fixes
3. **Fallback Template** - Option to use a simpler, validated template
4. **Support Contact** - Instructions for getting help

### Step 5: Output Delivery
You receive validated, runnable code including:
1. **Validated Python strategy file** - Fully tested and fixed
2. **Configuration template** - Str