PineForge roda backtests de Pine Script no CI: se algum trade mudar, o build quebra.
Por que paridade no CI
Estratégias driftam como qualquer código. Um rename de parâmetro, uma refatoração de função helper, uma mudança na API do Pine v6 que você não percebeu: qualquer um deles pode mexer silenciosamente nos sinais sem quebrar nenhum teste existente. Sem um gate de paridade no CI, um commit que você fez dois meses atrás pode mudar a lista de trades da semana passada e você só vai descobrir quando o P&L ao vivo ficar errado.
A disciplina de commitar sua lista de trades de referência junto com o source da estratégia é a mesma disciplina que faz software ser confiável: você descreve o output esperado e seu build quebra se o output real divergir. Pra um backtest, o output esperado é a lista de trades (barra de entrada, barra de saída, direção, tamanho, preço de execução) contra um dataset histórico fixado.
Quando essa comparação roda em todo commit, você ganha uma catraca: o comportamento histórico da sua estratégia só pode melhorar, nunca regredir por acidente. Você sabe exatamente qual commit mudou o output, porque o build quebrou nesse commit. Você tem um git blame pra sua curva de equity.
Isso importa mais do que a maioria dos quants percebe no começo. O abismo entre "testei essa estratégia" e "tenho um registro reproduzível, versionado, de cada sinal histórico que essa estratégia já produziu" é enorme. O primeiro é um print. O segundo é um audit trail. CI é como você mantém o segundo sem esforço manual em cada push.
O PineForge se encaixa aqui porque o runtime é uma imagem Docker: roda onde o Docker rodar, gera os mesmos trades para os mesmos dados de entrada e escreve um relatório JSON que você pode processar com jq. Não há navegador, login nem limite de requisições no backtest em si.
Exemplo em GitHub Actions
O fluxo completo: faz o checkout da sua estratégia, transpila para C++ com a imagem pineforge-release, roda o backtest no seu CSV de OHLCV fixado, lê o relatório JSON com jq, compara com sua baseline commitada e quebra o build se algum trade mudar de direção ou de barra, ou se o delta de PnL líquido passar do seu threshold.
O runtime é uma imagem de container, então não tem chave de API pra gerenciar. É só dar docker run no job. Crie .github/workflows/backtest.yml:
name: Backtest parity
on:
push:
branches: [main, "feat/**"]
pull_request:
jobs:
backtest:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
# Pin the image version so results only change when you change it.
- name: Transpile strategy to C++
run: |
docker run --rm --network=none \
-e PINEFORGE_TRANSPILE_ONLY=1 \
-v "$PWD/strategy.pine":/in/strategy.pine:ro \
ghcr.io/pineforge-4pass/pineforge-release:1.12.0 > strategy.cpp
- name: Run backtest
run: |
docker run --rm --network=none \
-v "$PWD/strategy.cpp":/in/strategy.cpp:ro \
-v "$PWD/data/ohlcv.csv":/in/ohlcv.csv:ro \
ghcr.io/pineforge-4pass/pineforge-release:1.12.0 \
> report.json
- name: Assert parity
run: |
# Every trade keeps its side and its entry and exit bars,
# and net P&L moves by at most THRESHOLD.
BARS='[.trades[] | [.side, .entry_bar_index, .exit_bar_index]]'
ACTUAL=$(jq '.summary.net_pnl' report.json)
BASELINE=$(jq '.summary.net_pnl' baseline/report.json)
DELTA=$(echo "$ACTUAL $BASELINE" | awk '{d=$1-$2; print (d<0)?-d:d}')
THRESHOLD="0.01"
if [ "$(jq -c "$BARS" report.json)" != "$(jq -c "$BARS" baseline/report.json)" ]; then
echo "Parity drift: a trade changed side, entry bar or exit bar"
elif awk "BEGIN{exit !($DELTA > $THRESHOLD)}"; then
echo "Parity drift: net_pnl delta $DELTA exceeds threshold $THRESHOLD"
else
echo "Parity OK - same sides and bars, net_pnl delta $DELTA (threshold $THRESHOLD)"
exit 0
fi
# One trade per line, so diff's line numbers are trade numbers.
TRADE='.trades[] | {side, entry_bar_index, exit_bar_index, entry_price, exit_price, qty, pnl}'
diff <(jq -c "$TRADE" baseline/report.json) <(jq -c "$TRADE" report.json)
exit 1Guarde seu relatório baseline em baseline/report.json no repo, commitado junto com o source da estratégia. Quando um PR muda o comportamento da estratégia de propósito, o autor atualiza a baseline como parte do PR. Esse diff vira um registro permanente do que mudou e por quê.
O mesmo fluxo de trabalho roda igual no GitLab CI, Bitbucket Pipelines ou qualquer runner que suporte Docker. Troque a sintaxe YAML, mantenha os comandos shell.
Exit codes e asserção de paridade
O runtime do PineForge sai com código 0 numa execução sem erros e com um código diferente de zero em caso de falha: 2 para arquivo de entrada ausente, 3 para falha de compilação, 4 para falha no backtest e 5 para falha de transpilação (Pine não suportado ou erro de sintaxe). O CI reconhece esses códigos sem nenhum tratamento especial.
A verificação do resultado fica por conta do seu fluxo de trabalho. O relatório tem este formato (resumido):
{
"engine": "pineforge",
...
"summary": {
"total_trades": 3483,
"wins": 1288,
"losses": 2194,
"win_rate_pct": 36.9796,
"net_pnl": 2518.39,
"max_drawdown": -1382.76,
...
},
"trades": [
{
"n": 1,
"side": "long",
"entry_time": 1729402200000,
"exit_time": 1729422000000,
"entry_price": 2640.96,
"exit_price": 2645.15,
"qty": 1.0,
"pnl": 4.19,
"entry_bar_index": 34,
"exit_bar_index": 56,
...
}
],
"metrics": { "all": { "profit_factor": 1.06, ... }, "equity": { "sharpe_tv": ..., ... } },
"equity_curve": [ ... ],
"fingerprint": { "digest": "sha256:...", ... }
}Pra um check numérico simples de paridade, compare summary.net_pnl e summary.total_trades contra a baseline. O fluxo de trabalho acima também lê o array trades: cada trade precisa manter a mesma direção e as mesmas barras de entrada e de saída. Quando uma verificação falha, o fluxo de trabalho faz o diff das duas listas de trades com um trade por linha; assim, os números de linha do diff são os números dos trades, e cada linha mostra a direção, as barras, os preços, a quantidade e o P&L de um trade, antes e depois.
Threshold prático pra campos numéricos: aceite deltas de ponto flutuante até 0.01 (um centavo de P&L líquido) e quebre em qualquer coisa maior. Para os trades, a tolerância é zero: o fluxo de trabalho acima falha com qualquer mudança de direção, de entry_bar_index ou exit_bar_index, seja qual for o P&L. Um trade que cai numa barra diferente significa que a sua lógica de sinal mudou.
Um padrão prático: atualize a baseline num passo separado do fluxo de trabalho, condicionado a um rótulo no PR, para que uma mudança intencional apareça na revisão de código ao lado da alteração no Pine que a causou.