Add custom-indicator skill to skill-templates/indicators/custom-indicator

Author: Ruuudy1

skill-templates/indicators/custom-indicator/SKILL.md

@@ -0,0 +1,252 @@
+---
+name: custom-indicator
+description: >
+  Creates a custom indicator class and integrates it into a QuantConnect algorithm via MCP.
+  Invoke when the user wants an indicator LEAN does not provide, needs to combine built-in
+  indicators beyond extension logic, or describes a formula to compute on price/volume data.
+  Trigger phrases: "create a custom indicator", "implement a custom [name] indicator",
+  "write an indicator for [formula]", "I need an indicator that LEAN doesn't have",
+  "add a custom indicator to my algorithm", "combine built-in indicators with custom logic",
+  "PythonIndicator", "custom indicator class", "write a [name] indicator".
+---
+
+# /custom-indicator -- QuantConnect Custom Indicator
+
+Creates a custom indicator class and wires it into an algorithm.
+
+---
+
+## Step 1 -- Gather Indicator Information
+
+Ask the user (sequentially if needed):
+
+1. **Indicator name**: What should the class be called? (e.g., `CustomVolatility`, `LogMomentum`)
+
+2. **Formula / logic**: What does this indicator compute? Describe the math or logic step by step.
+
+3. **Input type**:
+   - Single price value -> py`IndicatorDataPoint` (use py`input_.value`cs`input.Value`)
+   - Full OHLCV bar -> py`TradeBar` (use py`input_.close`cs`input.Close`, py`input_.volume`cs`input.Volume`, etc.)
+   - Quote bar (bid/ask) -> `QuoteBar`
+   - Default to `TradeBar` when the formula needs more than just a single price.
+
+4. **Period**: Does the indicator need a rolling lookback window? If yes, how many bars?
+   Use py`RollingWindow[float](period)`cs`RollingWindow<decimal>(period)`.
+
+5. **Internal built-in indicators**: Does the computation internally use any LEAN built-in
+   indicators (e.g., SMA, EMA, RSI)? If yes, list them. They must be constructed and updated
+   inside py`update`cs`ComputeNextValue`.
+
+6. **Algorithm scope**:
+   - Single fixed symbol -> register in py`initialize`cs`Initialize`
+   - Universe of symbols -> register in py`on_securities_changed`cs`OnSecuritiesChanged`, deregister on removal
+
+7. **Warm-up strategy** (default to manual):
+   - **Manual** (recommended): loop over py`self.history[TradeBar](symbol, period + 1)`cs`History<TradeBar>(symbol, period + 1, Resolution.Daily)` and call py`indicator.update(bar)`cs`indicator.Update(bar)` before py`self.register_indicator`cs`RegisterIndicator`.
+   - **Automatic**: set py`self.settings.automatic_indicator_warm_up = True`cs`Settings.AutomaticIndicatorWarmUp = true` in py`initialize`cs`Initialize`.
+
+---
+
+## Step 2 -- Generate the Code
+
+### Style rules
+
+Apply these rules to all generated code:
+
+- **Imports (Python)**: `from AlgorithmImports import *` only. `AlgorithmImports` already re-exports `math`, `numpy`, and all common libraries -- no additional imports needed.
+- **Imports (C#)**: Leave all project `using` statements as-is.
+- **Comments**: Capital first letter, space after `#` / `//`, ends with a period.
+- **Blank lines (Python)**: 2 blank lines before each class, 1 before each method, none inside method bodies.
+- **Blank lines (C#)**: 1 blank line between methods, none inside method bodies.
+
+### File naming
+
+| Language | Class name | File name |
+|---|---|---|
+| Python | `CustomVolatility` | `custom_volatility.py` |
+| C# | `CustomVolatility` | `CustomVolatility.cs` |
+
+The indicator class always goes in its own file. Never inline it in `main.py` / `Main.cs`.
+
+### Indicator class template
+
+```python
+# region imports
+from AlgorithmImports import *
+# endregion
+
+
+class CustomVolatility(PythonIndicator):
+
+    def __init__(self, period):
+        super().__init__()
+        self.value = 0
+        self._window = RollingWindow[float](period)
+
+    def update(self, input_: BaseData):
+        price = input_.value
+        if price <= 0:
+            return
+        self._window.add(price)
+        if self._window.is_ready:
+            prices = np.array(list(self._window)[::-1])
+            log_diffs = np.diff(np.log(prices))
+            self.value = np.std(log_diffs) * math.sqrt(252) * 100.0
+        return self.is_ready
+
+    @property
+    def is_ready(self) -> bool:
+        return self._window.is_ready
+```
+
+```csharp
+public class CustomVolatility : Indicator
+{
+    private readonly RollingWindow<decimal> _window;
+
+    public CustomVolatility(int period) : base("CustomVolatility")
+    {
+        _window = new RollingWindow<decimal>(period);
+        WarmUpPeriod = period;
+    }
+
+    public override bool IsReady => _window.IsReady;
+
+    protected override decimal ComputeNextValue(IndicatorDataPoint input)
+    {
+        _window.Add(input.Value);
+        if (!IsReady) return 0m;
+        // Compute from _window here.
+        return 0m;
+    }
+}
+```
+
+For OHLCV input in C#, inherit from `BarIndicator` instead of `Indicator`:
+
+```csharp
+public class CustomVolatility : BarIndicator
+{
+    public CustomVolatility(int period) : base("CustomVolatility")
+    {
+        WarmUpPeriod = period;
+    }
+
+    public override bool IsReady => true;
+
+    protected override decimal ComputeNextValue(IBaseDataBar input)
+    {
+        // input.Close, input.Open, input.High, input.Low, input.Volume
+        return 0m;
+    }
+}
+```
+
+Key rules:
+
+- Python: inherit from `PythonIndicator`, not `Indicator`.
+- py`self.value`cs`Value` holds the current computed value.
+- py`update` must return py`self.is_ready`cs`IsReady` (bool). Omitting the return silently breaks warm-up.
+- Guard invalid input (e.g., `price <= 0`) before touching the window.
+- `RollingWindow` iterates newest-first in Python; use `[::-1]` to get chronological order for numpy.
+- C#: set `WarmUpPeriod` in the constructor so LEAN knows how many bars are needed.
+
+### Algorithm integration -- single symbol
+
+```python
+def initialize(self):
+    symbol = self.add_equity("SPY", Resolution.DAILY).symbol
+    self._indicator = CustomVolatility(period)
+    for bar in self.history[TradeBar](symbol, period + 1):
+        self._indicator.update(bar)
+    self.register_indicator(symbol, self._indicator)
+```
+
+```csharp
+private CustomVolatility _indicator;
+
+public override void Initialize()
+{
+    var symbol = AddEquity("SPY", Resolution.Daily).Symbol;
+    _indicator = new CustomVolatility(period);
+    foreach (var bar in History<TradeBar>(symbol, period + 1, Resolution.Daily))
+        _indicator.Update(bar);
+    RegisterIndicator(symbol, _indicator);
+}
+```
+
+### Algorithm integration -- universe
+
+```python
+def on_securities_changed(self, changes):
+    for security in changes.added_securities:
+        security.indicator = CustomVolatility(period)
+        for bar in self.history[TradeBar](security, period + 1):
+            security.indicator.update(bar)
+        self.register_indicator(security, security.indicator)
+    for security in changes.removed_securities:
+        self.deregister_indicator(security.indicator)
+        self.liquidate(security)
+```
+
+```csharp
+private readonly Dictionary<Symbol, CustomVolatility> _indicators = new();
+
+public override void OnSecuritiesChanged(SecurityChanges changes)
+{
+    foreach (var security in changes.AddedSecurities)
+    {
+        var ind = new CustomVolatility(period);
+        foreach (var bar in History<TradeBar>(security.Symbol, period + 1, Resolution.Daily))
+            ind.Update(bar);
+        RegisterIndicator(security.Symbol, ind);
+        _indicators[security.Symbol] = ind;
+    }
+    foreach (var security in changes.RemovedSecurities)
+    {
+        if (_indicators.Remove(security.Symbol, out var ind))
+            DeregisterIndicator(ind);
+        Liquidate(security.Symbol);
+    }
+}
+```
+
+Gate all reads on py`security.indicator.is_ready`cs`_indicators[symbol].IsReady` before accessing the value.
+
+---
+
+## Step 3 -- Write Files via MCP
+
+1. **Indicator file**: `quantconnect:create_file` with the indicator class.
+2. **Algorithm file**: `quantconnect:update_file_contents` for `main.py` / `Main.cs`.
+3. Python only: add import after `from AlgorithmImports import *`:
+   ```python
+   from custom_volatility import CustomVolatility
+   ```
+   C# does not need this -- all project files share the same namespace.
+
+---
+
+## Step 4 -- Compile
+
+1. `quantconnect:create_compile`.
+2. Poll `quantconnect:read_compile` until `BuildSuccess` or `BuildError`.
+3. On `BuildError`: parse error messages, fix code via MCP, loop back to Step 4.
+
+---
+
+## Step 5 -- Backtest and Verify
+
+1. `quantconnect:create_backtest`.
+2. Poll `quantconnect:read_backtest` until complete.
+3. Check both conditions:
+
+   **Condition A: Indicator produces values**
+   - Look for runtime errors about indicator not being ready.
+   - If py`is_ready`cs`IsReady` never becomes true: verify py`history`cs`History` returned at least `period` bars and that py`update`cs`Update` is called on each. Fix the warm-up loop and re-run from Step 4.
+
+   **Condition B: Algorithm logic fires**
+   - If algorithm has entry/exit conditions: confirm at least one order was placed.
+   - If no orders but no errors: add a log line as the first line of py`on_data`cs`OnData` and re-backtest. Relax the entry condition if needed.
+
+4. Report: compile clean, backtest complete, indicator py`is_ready`cs`IsReady` confirmed, trades placed.