whchien/ai-trader/add-strategy

$ /add-strategy classic
 
Creating a classic single-stock strategy.
 
What should we name this strategy? (e.g., "BollingerBreakout")
> MACDBBands
 
Brief description (1-2 sentences)?
> Combines MACD for trend and Bollinger Bands for entry timing
 
Parameters with defaults? (e.g., "fast=12, slow=26, signal=9, bb_period=20")
> fast=12, slow=26, signal=9, bb_period=20, bb_dev=2
 
Entry condition (buy signal)?
> MACD crosses above signal line AND price below lower Bollinger Band
 
Exit condition (sell signal)?
> MACD crosses below signal line OR price above upper Bollinger Band
 
Any custom indicators from indicators.py? (e.g., DoubleTop, RSRS)
> No
 
[Preview shown]
 
Proceed with creation? (yes/no)
> yes
 
✓ Created macd_bbands.py
✓ Updated classic/__init__.py (added import)
✓ Updated classic/__init__.py (added to __all__)
✓ Verified file is importable
 
Next steps:
1. Test standalone: python ai_trader/backtesting/strategies/classic/macd_bbands.py
2. Review generated code and refine logic
3. Test via CLI: ai-trader quick MACDBBandsStrategy your_data.csv
4. Check changes: git diff
5. Commit when ready

$ /add-strategy portfolio
 
Creating a portfolio multi-asset strategy.
 
What should we name this strategy? (e.g., "MomentumRotation")
> TripleEMARotation
 
Brief description?
> Rotates portfolio to assets with strongest triple EMA alignment
 
Parameters?
> short_ema=10, med_ema=20, long_ema=50, top_k=5
 
Rotation/Rebalancing logic?
> Rotate monthly to top-5 assets where all three EMAs are bullishly aligned
 
Custom indicators?
> No
 
[Preview shown]
 
Proceed with creation? (yes/no)
> yes
 
✓ Created triple_ema_rotation.py
✓ Updated portfolio/__init__.py (added import)
✓ Updated portfolio/__init__.py (added to __all__)
✓ Verified file is importable

"""
[Strategy Name]
[1-2 sentence description of what the strategy does and the market conditions it targets.]
"""
import backtrader as bt
from ai_trader.backtesting.strategies.base import BaseStrategy
# [Add custom indicator imports if needed]
# from ai_trader.backtesting.strategies.indicators import CustomIndicator
class [StrategyName]Strategy(BaseStrategy):
    """
    [Strategy Name] - [One-line tagline describing the core approach].
    [Detailed description paragraph explaining the trading logic, market conditions,
    and why this strategy works in those conditions.]
    Entry Logic (Buy):
    - Condition 1
    - Condition 2
    Exit Logic (Sell):
    - Condition 1
    - Condition 2
    Parameters:
    - param_name (type): Description [default: value]
    Notes:
    - Insight 1
    - Insight 2
    """
    params = dict(param1=value1, param2=value2)
    def __init__(self):
        """Initialize indicators and signals."""
        super().__init__()
        # Initialize indicators here
        # self.indicator = bt.indicators.SMA(self.data)
    def next(self):
        """Execute trading logic each bar."""
        if self.position.size == 0:
            # Check buy signal and enter
            pass
        else:
            # Check exit signal and close
            pass
if __name__ == "__main__":
    from ai_trader.utils.backtest import run_backtest
    # Run backtest with [StrategyName]Strategy
    results = run_backtest(
        strategy=[StrategyName]Strategy,
        data_source=None,  # Use example data
        cash=1000000,
        commission=0.001425,
    )
    print("Backtest completed! Use cerebro.plot() to visualize results.")

"""
[Strategy Name]
[1-2 sentence description of the portfolio rotation strategy.]
"""
import backtrader as bt
from ai_trader.backtesting.strategies.base import BaseStrategy
# [Add custom indicator imports if needed]
class [StrategyName]Strategy(BaseStrategy):
    """
    [Strategy Name] - [One-line tagline].
    [Detailed description of the rotation/rebalancing logic.]
    Entry Logic (Buy):
    - Condition 1 (applies to each asset in the portfolio)
    - Condition 2
    Exit Logic (Sell):
    - Condition 1
    - Asset no longer in top-k performers
    Parameters:
    - param_name (type): Description [default: value]
    Notes:
    - Rotates portfolio based on selection criteria
    - Equal-weight or custom allocation across selected assets
    - Rebalances when conditions change
    """
    params = dict(param1=value1, top_k=5)
    def __init__(self):
        """Initialize indicators for all assets."""
        super().__init__()
        self.indicators = {
            data: bt.ind.SMA(data) for data in self.datas
        }
        self.top_k = self.params.top_k
    def next(self):
        """Execute portfolio rebalancing logic."""
        # Get current holdings
        holding = [d for d, pos in self.getpositions().items() if pos]
        # Identify candidates and exits
        to_buy = [data for data in self.datas if self._is_buy_signal(data)]
        to_close = [data for data in self.datas if self._is_exit_signal(data)]
        # Close positions in assets with exit signals
        for data in to_close:
            if data in holding:
                self.order_target_percent(data=data, target=0.0)
                self.log(f"Exit {data._name}")
        # Select top-k by performance
        portfolio = list(set(to_buy + holding))
        if not portfolio:
            return
        if len(portfolio) > self.top_k:
            # Rank by indicator and select top-k
            ranked = sorted(
                [(d, self.indicators[d][0]) for d in portfolio],
                key=lambda x: x[1],
                reverse=True,
            )
            portfolio = [d for d, _ in ranked[:self.top_k]]
        # Equal-weight allocation
        weight = 1 / len(portfolio)
        for data in portfolio:
            self.order_target_percent(data, target=weight * 0.95)
    def _is_buy_signal(self, data):
        """Check if data meets buy criteria."""
        # Implement your entry logic
        return False
    def _is_exit_signal(self, data):
        """Check if data meets exit criteria."""
        # Implement your exit logic
        return False
if __name__ == "__main__":
    from ai_trader.utils.backtest import run_backtest
    # Run backtest with [StrategyName]Strategy
    results = run_backtest(
        strategy=[StrategyName]Strategy,
        data_source=None,  # Use example data
        cash=1000000,
        commission=0.001425,
    )
    print("Backtest completed! Use cerebro.plot() to visualize results.")

# Before
from ai_trader.backtesting.strategies.classic.bbands import BBandsStrategy
from ai_trader.backtesting.strategies.classic.double_top import DoubleTopStrategy
__all__ = [
    "BBandsStrategy",
    "DoubleTopStrategy",
    # ...
]
# After
from ai_trader.backtesting.strategies.classic.bbands import BBandsStrategy
from ai_trader.backtesting.strategies.classic.double_top import DoubleTopStrategy
from ai_trader.backtesting.strategies.classic.macd_bbands import MACDBBandsStrategy
__all__ = [
    "BBandsStrategy",
    "DoubleTopStrategy",
    "MACDBBandsStrategy",
    # ...
]