@dshtrading/strategies 0.1.0

package/lib/engine.js

@@ -0,0 +1,165 @@
+//#region src/engine.ts
+const DEFAULT_INITIAL_CAPITAL = 1e5;
+const DEFAULT_FEE_RATE = .001;
+const MS_PER_YEAR = 315576e5;
+/** 推断一年的 bar 根数（根据相邻 K 线平均时间间隔）。 */
+function estimateBarsPerYear(bars) {
+	if (bars.length < 2) return 250;
+	const totalSpan = bars[bars.length - 1].openTime - bars[0].openTime;
+	if (totalSpan <= 0) return 250;
+	const avgInterval = totalSpan / (bars.length - 1);
+	if (avgInterval <= 0) return 250;
+	const barsPerYear = MS_PER_YEAR / avgInterval;
+	return Math.max(1, Math.min(barsPerYear, 525600));
+}
+function run(bars, strategy, paramsOverride = {}, options = {}) {
+	const initialCapital = options.initialCapital ?? DEFAULT_INITIAL_CAPITAL;
+	const feeRate = options.feeRate ?? DEFAULT_FEE_RATE;
+	const slippage = options.slippage ?? 0;
+	if (!bars || bars.length === 0) return {
+		signals: [],
+		trades: [],
+		equity: [],
+		metrics: {
+			totalReturn: 0,
+			cagr: 0,
+			maxDrawdown: 0,
+			sharpe: 0,
+			winRate: 0,
+			profitFactor: 0,
+			tradeCount: 0,
+			exposure: 0
+		},
+		initialCapital,
+		finalCapital: initialCapital
+	};
+	const resolvedParams = {};
+	for (const p of strategy.params) resolvedParams[p.key] = paramsOverride[p.key] ?? p.default;
+	const signals = strategy.compute(bars, resolvedParams);
+	const signalMap = /* @__PURE__ */ new Map();
+	for (const s of signals) if (s.index >= 0 && s.index < bars.length) signalMap.set(s.index, s);
+	let cash = initialCapital;
+	let shares = 0;
+	let position = "flat";
+	let entryIndex = -1;
+	let entryTime = 0;
+	let entryPrice = 0;
+	let entryCashCost = 0;
+	let totalHoldingBars = 0;
+	const trades = [];
+	const equityPoints = [];
+	let peakEquity = initialCapital;
+	let maxDrawdown = 0;
+	for (let i = 0; i < bars.length; i++) {
+		const currentBar = bars[i];
+		if (i > 0) {
+			const prevSignal = signalMap.get(i - 1);
+			if (prevSignal) {
+				if (prevSignal.action === "entry" && position === "flat") {
+					const executedBuyPrice = currentBar.open * (1 + slippage);
+					if (executedBuyPrice > 0) {
+						const costPerShare = executedBuyPrice * (1 + feeRate);
+						shares = cash / costPerShare;
+						entryCashCost = cash;
+						cash = 0;
+						position = "long";
+						entryIndex = i;
+						entryTime = currentBar.openTime;
+						entryPrice = executedBuyPrice;
+					}
+				} else if (prevSignal.action === "exit" && position === "long") {
+					const executedSellPrice = currentBar.open * (1 - slippage);
+					const netCash = shares * executedSellPrice * (1 - feeRate);
+					const profit = netCash - entryCashCost;
+					const returnPercent = (executedSellPrice / entryPrice * (1 - feeRate) / (1 + feeRate) - 1) * 100;
+					const holdingBars = i - entryIndex;
+					trades.push({
+						entryIndex,
+						entryTime,
+						entryPrice,
+						exitIndex: i,
+						exitTime: currentBar.openTime,
+						exitPrice: executedSellPrice,
+						returnPercent,
+						profit,
+						holdingBars,
+						exitReason: prevSignal.reason,
+						...prevSignal.reasonKey !== void 0 ? { exitReasonKey: prevSignal.reasonKey } : {},
+						...prevSignal.reasonParams !== void 0 ? { exitReasonParams: prevSignal.reasonParams } : {}
+					});
+					cash = netCash;
+					shares = 0;
+					position = "flat";
+					entryIndex = -1;
+				}
+			}
+		}
+		if (position === "long") totalHoldingBars += 1;
+		let currentEquity;
+		if (position === "long") currentEquity = shares * currentBar.close * (1 - feeRate);
+		else currentEquity = cash;
+		if (currentEquity > peakEquity) peakEquity = currentEquity;
+		const currentDrawdown = peakEquity > 0 ? (currentEquity - peakEquity) / peakEquity * 100 : 0;
+		if (currentDrawdown < maxDrawdown) maxDrawdown = currentDrawdown;
+		equityPoints.push({
+			time: currentBar.openTime,
+			equity: currentEquity,
+			drawdownPercent: currentDrawdown
+		});
+	}
+	const finalCapital = equityPoints[equityPoints.length - 1]?.equity ?? initialCapital;
+	const totalReturn = (finalCapital - initialCapital) / initialCapital * 100;
+	const tradeCount = trades.length;
+	const winningTrades = trades.filter((t) => t.profit > 0);
+	const winRate = tradeCount > 0 ? winningTrades.length / tradeCount * 100 : 0;
+	const totalWinAmount = trades.filter((t) => t.profit > 0).reduce((sum, t) => sum + t.profit, 0);
+	const totalLossAmount = trades.filter((t) => t.profit < 0).reduce((sum, t) => sum + Math.abs(t.profit), 0);
+	let profitFactor = 0;
+	if (totalLossAmount === 0) profitFactor = totalWinAmount > 0 ? Infinity : 0;
+	else profitFactor = totalWinAmount / totalLossAmount;
+	const exposure = bars.length > 0 ? totalHoldingBars / bars.length * 100 : 0;
+	let cagr = 0;
+	if (bars.length > 1) {
+		const years = (bars[bars.length - 1].openTime - bars[0].openTime) / MS_PER_YEAR;
+		if (years > .01 && finalCapital > 0) cagr = (Math.pow(finalCapital / initialCapital, 1 / years) - 1) * 100;
+		else if (finalCapital <= 0) cagr = -100;
+	}
+	let sharpe = 0;
+	if (equityPoints.length > 1) {
+		const returns = [];
+		for (let k = 1; k < equityPoints.length; k++) {
+			const prev = equityPoints[k - 1].equity;
+			const curr = equityPoints[k].equity;
+			if (prev > 0) returns.push((curr - prev) / prev);
+			else returns.push(0);
+		}
+		if (returns.length > 1) {
+			const mean = returns.reduce((sum, r) => sum + r, 0) / returns.length;
+			const variance = returns.reduce((sum, r) => sum + Math.pow(r - mean, 2), 0) / (returns.length - 1);
+			const stdev = Math.sqrt(variance);
+			if (stdev > 0) {
+				const annualFactor = Math.sqrt(estimateBarsPerYear(bars));
+				sharpe = mean / stdev * annualFactor;
+			}
+		}
+	}
+	return {
+		signals,
+		trades,
+		equity: equityPoints,
+		metrics: {
+			totalReturn,
+			cagr,
+			maxDrawdown,
+			sharpe,
+			winRate,
+			profitFactor,
+			tradeCount,
+			exposure
+		},
+		initialCapital,
+		finalCapital
+	};
+}
+//#endregion
+export { run };

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+import { BacktestMetrics, BacktestOptions, BacktestResult, EquityPoint, Kline, SignalAction, StrategyDefinition, StrategyHorizon, StrategyParamSpec, StrategySignal, TradeRecord } from "./types.js";
+import { run } from "./engine.js";
+import { CustomStrategyRecord, CustomStrategyStore, createMemoryCustomStrategyStore } from "./custom.js";
+import { StrategyValidationResult, compileStrategySource, validateCustomStrategy, validateSignalSequence } from "./validate.js";
+import { ScreenerColumnSpec, ScreenerDefinition, ScreenerMatch } from "./screeners/types.js";
+import { getScreenerById, screenerParadigms } from "./screeners/index.js";
+import { donchianBreakoutStrategy } from "./paradigms/donchian-breakout.js";
+import { rsiReversionStrategy } from "./paradigms/rsi-reversion.js";
+import { emaCrossoverStrategy } from "./paradigms/ema-crossover.js";
+import { bollingerReversionStrategy } from "./paradigms/bollinger-reversion.js";
+import { smaBaselineStrategy } from "./paradigms/sma-baseline.js";
+import { momentum12mStrategy } from "./paradigms/momentum-12m.js";
+import { getStrategyById, strategyParadigms } from "./paradigms/index.js";
+export { type BacktestMetrics, type BacktestOptions, type BacktestResult, type CustomStrategyRecord, type CustomStrategyStore, type EquityPoint, type Kline, type ScreenerColumnSpec, type ScreenerDefinition, type ScreenerMatch, type SignalAction, type StrategyDefinition, type StrategyHorizon, type StrategyParamSpec, type StrategySignal, type StrategyValidationResult, type TradeRecord, bollingerReversionStrategy, compileStrategySource, createMemoryCustomStrategyStore, donchianBreakoutStrategy, emaCrossoverStrategy, getScreenerById, getStrategyById, momentum12mStrategy, rsiReversionStrategy, run, screenerParadigms, smaBaselineStrategy, strategyParadigms, validateCustomStrategy, validateSignalSequence };

package/lib/index.js

@@ -0,0 +1,12 @@
+import { run } from "./engine.js";
+import { createMemoryCustomStrategyStore } from "./custom.js";
+import { compileStrategySource, validateCustomStrategy, validateSignalSequence } from "./validate.js";
+import { getScreenerById, screenerParadigms } from "./screeners/index.js";
+import { donchianBreakoutStrategy } from "./paradigms/donchian-breakout.js";
+import { rsiReversionStrategy } from "./paradigms/rsi-reversion.js";
+import { emaCrossoverStrategy } from "./paradigms/ema-crossover.js";
+import { bollingerReversionStrategy } from "./paradigms/bollinger-reversion.js";
+import { smaBaselineStrategy } from "./paradigms/sma-baseline.js";
+import { momentum12mStrategy } from "./paradigms/momentum-12m.js";
+import { getStrategyById, strategyParadigms } from "./paradigms/index.js";
+export { bollingerReversionStrategy, compileStrategySource, createMemoryCustomStrategyStore, donchianBreakoutStrategy, emaCrossoverStrategy, getScreenerById, getStrategyById, momentum12mStrategy, rsiReversionStrategy, run, screenerParadigms, smaBaselineStrategy, strategyParadigms, validateCustomStrategy, validateSignalSequence };

package/lib/paradigms/bollinger-reversion.d.ts

@@ -0,0 +1,5 @@
+import { StrategyDefinition } from "../types.js";
+//#region src/paradigms/bollinger-reversion.d.ts
+declare const bollingerReversionStrategy: StrategyDefinition;
+//#endregion
+export { bollingerReversionStrategy };

package/lib/paradigms/bollinger-reversion.js

@@ -0,0 +1,77 @@
+import { bollinger } from "@dshtrading/indicators";
+//#region src/paradigms/bollinger-reversion.ts
+/**
+* 布林带下轨均值回归策略（波段）。
+*
+* 入场：收盘价跌破布林线下轨（超卖错杀）。
+* 出场：收盘价回归至布林带中轨（均线目标位平仓）。
+*/
+const bollingerReversionStrategy = {
+	id: "bollinger-reversion",
+	horizon: "swing",
+	name: "布林带下轨均值回归",
+	summary: "价格跌破布林线下轨时介入抄底，反弹至中轨（基准均线）时平仓（波段通道回归）",
+	params: [{
+		key: "period",
+		label: "布林周期",
+		default: 20,
+		min: 5,
+		max: 50,
+		step: 1
+	}, {
+		key: "multiplier",
+		label: "标准差倍数 (k)",
+		default: 2,
+		min: 1,
+		max: 4,
+		step: .5
+	}],
+	compute(bars, params) {
+		const period = Math.max(5, Math.round(params.period ?? 20));
+		const k = Number(params.multiplier ?? 2);
+		const closes = bars.map((b) => b.close);
+		const { mid, lower } = bollinger(closes, period, k);
+		const signals = [];
+		let inPosition = false;
+		for (let i = period - 1; i < bars.length; i++) {
+			const currentClose = bars[i].close;
+			const currentLower = lower[i];
+			const currentMid = mid[i];
+			if (currentLower === void 0 || currentMid === void 0) continue;
+			if (!inPosition && currentClose < currentLower) {
+				signals.push({
+					index: i,
+					time: bars[i].openTime,
+					action: "entry",
+					direction: "long",
+					price: currentClose,
+					reason: `收盘价 (${currentClose.toFixed(2)}) 跌破布林下轨 (${currentLower.toFixed(2)})，触发波段均值回归`,
+					reasonKey: "strat.bollinger-reversion.reason.entry",
+					reasonParams: {
+						close: currentClose.toFixed(2),
+						band: currentLower.toFixed(2)
+					}
+				});
+				inPosition = true;
+			} else if (inPosition && currentClose >= currentMid) {
+				signals.push({
+					index: i,
+					time: bars[i].openTime,
+					action: "exit",
+					direction: "flat",
+					price: currentClose,
+					reason: `收盘价 (${currentClose.toFixed(2)}) 成功回归至布林中轨 (${currentMid.toFixed(2)})，完成目标止盈`,
+					reasonKey: "strat.bollinger-reversion.reason.exit",
+					reasonParams: {
+						close: currentClose.toFixed(2),
+						mid: currentMid.toFixed(2)
+					}
+				});
+				inPosition = false;
+			}
+		}
+		return signals;
+	}
+};
+//#endregion
+export { bollingerReversionStrategy };

package/lib/paradigms/donchian-breakout.d.ts

@@ -0,0 +1,5 @@
+import { StrategyDefinition } from "../types.js";
+//#region src/paradigms/donchian-breakout.d.ts
+declare const donchianBreakoutStrategy: StrategyDefinition;
+//#endregion
+export { donchianBreakoutStrategy };

package/lib/paradigms/donchian-breakout.js

@@ -0,0 +1,71 @@
+//#region src/paradigms/donchian-breakout.ts
+const donchianBreakoutStrategy = {
+	id: "donchian-breakout",
+	horizon: "short",
+	name: "唐奇安通道突破",
+	summary: "收盘价突破前 N1 根最高价做多，跌破前 N2 根最低价离场（海龟经典简化版）",
+	params: [{
+		key: "lookbackEntry",
+		label: "突破周期 (N1)",
+		default: 20,
+		min: 5,
+		max: 100,
+		step: 1
+	}, {
+		key: "lookbackExit",
+		label: "离场周期 (N2)",
+		default: 10,
+		min: 2,
+		max: 50,
+		step: 1
+	}],
+	compute(bars, params) {
+		const n1 = Math.max(2, Math.round(params.lookbackEntry ?? 20));
+		const n2 = Math.max(1, Math.round(params.lookbackExit ?? 10));
+		const signals = [];
+		let inPosition = false;
+		for (let i = Math.max(n1, n2); i < bars.length; i++) {
+			const currentClose = bars[i].close;
+			let highestHigh = -Infinity;
+			for (let j = i - n1; j < i; j++) if (bars[j].high > highestHigh) highestHigh = bars[j].high;
+			let lowestLow = Infinity;
+			for (let j = i - n2; j < i; j++) if (bars[j].low < lowestLow) lowestLow = bars[j].low;
+			if (!inPosition && currentClose > highestHigh) {
+				signals.push({
+					index: i,
+					time: bars[i].openTime,
+					action: "entry",
+					direction: "long",
+					price: currentClose,
+					reason: `收盘价 (${currentClose.toFixed(2)}) 突破前 ${n1} 根最高价 (${highestHigh.toFixed(2)})`,
+					reasonKey: "strat.donchian-breakout.reason.entry",
+					reasonParams: {
+						close: currentClose.toFixed(2),
+						n: n1,
+						high: highestHigh.toFixed(2)
+					}
+				});
+				inPosition = true;
+			} else if (inPosition && currentClose < lowestLow) {
+				signals.push({
+					index: i,
+					time: bars[i].openTime,
+					action: "exit",
+					direction: "flat",
+					price: currentClose,
+					reason: `收盘价 (${currentClose.toFixed(2)}) 跌破前 ${n2} 根最低价 (${lowestLow.toFixed(2)})`,
+					reasonKey: "strat.donchian-breakout.reason.exit",
+					reasonParams: {
+						close: currentClose.toFixed(2),
+						n: n2,
+						low: lowestLow.toFixed(2)
+					}
+				});
+				inPosition = false;
+			}
+		}
+		return signals;
+	}
+};
+//#endregion
+export { donchianBreakoutStrategy };

package/lib/paradigms/ema-crossover.d.ts

@@ -0,0 +1,5 @@
+import { StrategyDefinition } from "../types.js";
+//#region src/paradigms/ema-crossover.d.ts
+declare const emaCrossoverStrategy: StrategyDefinition;
+//#endregion
+export { emaCrossoverStrategy };

package/lib/paradigms/ema-crossover.js

@@ -0,0 +1,83 @@
+import { ema } from "@dshtrading/indicators";
+//#region src/paradigms/ema-crossover.ts
+/**
+* 双均线趋势跟踪策略（波段）。
+*
+* 入场：EMA(fast) 上穿 EMA(slow) 金叉做多。
+* 出场：EMA(fast) 下穿 EMA(slow) 死叉离场。
+*/
+const emaCrossoverStrategy = {
+	id: "ema-crossover",
+	horizon: "swing",
+	name: "EMA 双均线趋势跟踪",
+	summary: "快线 EMA 上穿慢线 EMA 金叉做多，死叉平仓（经典中线波段趋势策略）",
+	params: [{
+		key: "fastPeriod",
+		label: "快线周期 (Fast)",
+		default: 20,
+		min: 5,
+		max: 50,
+		step: 1
+	}, {
+		key: "slowPeriod",
+		label: "慢线周期 (Slow)",
+		default: 60,
+		min: 20,
+		max: 200,
+		step: 1
+	}],
+	compute(bars, params) {
+		const fastP = Math.max(2, Math.round(params.fastPeriod ?? 20));
+		const slowP = Math.max(fastP + 1, Math.round(params.slowPeriod ?? 60));
+		const closes = bars.map((b) => b.close);
+		const fastEma = ema(closes, fastP);
+		const slowEma = ema(closes, slowP);
+		const signals = [];
+		let inPosition = false;
+		for (let i = 1; i < bars.length; i++) {
+			const prevFast = fastEma[i - 1];
+			const prevSlow = slowEma[i - 1];
+			const currFast = fastEma[i];
+			const currSlow = slowEma[i];
+			if (prevFast === void 0 || prevSlow === void 0 || currFast === void 0 || currSlow === void 0) continue;
+			if (!inPosition && prevFast <= prevSlow && currFast > currSlow) {
+				signals.push({
+					index: i,
+					time: bars[i].openTime,
+					action: "entry",
+					direction: "long",
+					price: bars[i].close,
+					reason: `EMA(${fastP}) (${currFast.toFixed(2)}) 上穿 EMA(${slowP}) (${currSlow.toFixed(2)}) 形成金叉`,
+					reasonKey: "strat.ema-crossover.reason.entry",
+					reasonParams: {
+						fastP,
+						fast: currFast.toFixed(2),
+						slowP,
+						slow: currSlow.toFixed(2)
+					}
+				});
+				inPosition = true;
+			} else if (inPosition && prevFast >= prevSlow && currFast < currSlow) {
+				signals.push({
+					index: i,
+					time: bars[i].openTime,
+					action: "exit",
+					direction: "flat",
+					price: bars[i].close,
+					reason: `EMA(${fastP}) (${currFast.toFixed(2)}) 下穿 EMA(${slowP}) (${currSlow.toFixed(2)}) 形成死叉`,
+					reasonKey: "strat.ema-crossover.reason.exit",
+					reasonParams: {
+						fastP,
+						fast: currFast.toFixed(2),
+						slowP,
+						slow: currSlow.toFixed(2)
+					}
+				});
+				inPosition = false;
+			}
+		}
+		return signals;
+	}
+};
+//#endregion
+export { emaCrossoverStrategy };

package/lib/paradigms/index.d.ts

@@ -0,0 +1,12 @@
+import { StrategyDefinition } from "../types.js";
+import { donchianBreakoutStrategy } from "./donchian-breakout.js";
+import { rsiReversionStrategy } from "./rsi-reversion.js";
+import { emaCrossoverStrategy } from "./ema-crossover.js";
+import { bollingerReversionStrategy } from "./bollinger-reversion.js";
+import { smaBaselineStrategy } from "./sma-baseline.js";
+import { momentum12mStrategy } from "./momentum-12m.js";
+//#region src/paradigms/index.d.ts
+declare const strategyParadigms: readonly StrategyDefinition[];
+declare function getStrategyById(id: string): StrategyDefinition | undefined;
+//#endregion
+export { bollingerReversionStrategy, donchianBreakoutStrategy, emaCrossoverStrategy, getStrategyById, momentum12mStrategy, rsiReversionStrategy, smaBaselineStrategy, strategyParadigms };

package/lib/paradigms/index.js

@@ -0,0 +1,23 @@
+import { donchianBreakoutStrategy } from "./donchian-breakout.js";
+import { rsiReversionStrategy } from "./rsi-reversion.js";
+import { emaCrossoverStrategy } from "./ema-crossover.js";
+import { bollingerReversionStrategy } from "./bollinger-reversion.js";
+import { smaBaselineStrategy } from "./sma-baseline.js";
+import { momentum12mStrategy } from "./momentum-12m.js";
+//#region src/paradigms/index.ts
+/**
+* 6 个经典策略参考范式汇聚。
+*/
+const strategyParadigms = [
+	donchianBreakoutStrategy,
+	rsiReversionStrategy,
+	emaCrossoverStrategy,
+	bollingerReversionStrategy,
+	smaBaselineStrategy,
+	momentum12mStrategy
+];
+function getStrategyById(id) {
+	return strategyParadigms.find((s) => s.id === id);
+}
+//#endregion
+export { bollingerReversionStrategy, donchianBreakoutStrategy, emaCrossoverStrategy, getStrategyById, momentum12mStrategy, rsiReversionStrategy, smaBaselineStrategy, strategyParadigms };

package/lib/paradigms/momentum-12m.d.ts

@@ -0,0 +1,5 @@
+import { StrategyDefinition } from "../types.js";
+//#region src/paradigms/momentum-12m.d.ts
+declare const momentum12mStrategy: StrategyDefinition;
+//#endregion
+export { momentum12mStrategy };

package/lib/paradigms/momentum-12m.js

@@ -0,0 +1,73 @@
+import { sma } from "@dshtrading/indicators";
+//#region src/paradigms/momentum-12m.ts
+/**
+* 12 个月动量择时策略（长线，Fama-French 动量单标的经典化）。
+*
+* 入场：近 12 个月（约 250 根日 K）累计收益 > 0 且价格高于年线，强动量做多。
+* 出场：动量转负或价格跌破年线，动量衰竭离场。
+*/
+const momentum12mStrategy = {
+	id: "momentum-12m",
+	horizon: "long",
+	name: "12 个月动量择时",
+	summary: "近 12 个月动量为正且站上年线做多，动量转负或破位离场（低换手长线动量）",
+	params: [{
+		key: "lookbackBars",
+		label: "动量回溯周期 (K线)",
+		default: 250,
+		min: 50,
+		max: 500,
+		step: 10
+	}],
+	compute(bars, params) {
+		const lookback = Math.max(10, Math.round(params.lookbackBars ?? 250));
+		const closes = bars.map((b) => b.close);
+		const smaValues = sma(closes, lookback);
+		const signals = [];
+		let inPosition = false;
+		for (let i = lookback; i < bars.length; i++) {
+			const currentClose = bars[i].close;
+			const pastClose = bars[i - lookback].close;
+			const currentSma = smaValues[i];
+			if (pastClose <= 0 || currentSma === void 0) continue;
+			const momentumReturn = (currentClose - pastClose) / pastClose;
+			if (!inPosition && momentumReturn > 0 && currentClose > currentSma) {
+				signals.push({
+					index: i,
+					time: bars[i].openTime,
+					action: "entry",
+					direction: "long",
+					price: currentClose,
+					reason: `近 ${lookback} 周期动量为正 (+${(momentumReturn * 100).toFixed(1)}%) 且位于均线 (${currentSma.toFixed(2)}) 之上，确认强动量`,
+					reasonKey: "strat.momentum-12m.reason.entry",
+					reasonParams: {
+						n: lookback,
+						pct: (momentumReturn * 100).toFixed(1),
+						sma: currentSma.toFixed(2)
+					}
+				});
+				inPosition = true;
+			} else if (inPosition && (momentumReturn <= 0 || currentClose < currentSma)) {
+				const exitCause = momentumReturn <= 0 ? "动量转为负值" : "跌破基准均线";
+				signals.push({
+					index: i,
+					time: bars[i].openTime,
+					action: "exit",
+					direction: "flat",
+					price: currentClose,
+					reason: `${exitCause} (${(momentumReturn * 100).toFixed(1)}% / SMA ${currentSma.toFixed(2)})，动量衰减平仓`,
+					reasonKey: "strat.momentum-12m.reason.exit",
+					reasonParams: {
+						cause: momentumReturn <= 0 ? "momentumNegative" : "belowBaseline",
+						pct: (momentumReturn * 100).toFixed(1),
+						sma: currentSma.toFixed(2)
+					}
+				});
+				inPosition = false;
+			}
+		}
+		return signals;
+	}
+};
+//#endregion
+export { momentum12mStrategy };

package/lib/paradigms/rsi-reversion.d.ts

@@ -0,0 +1,5 @@
+import { StrategyDefinition } from "../types.js";
+//#region src/paradigms/rsi-reversion.d.ts
+declare const rsiReversionStrategy: StrategyDefinition;
+//#endregion
+export { rsiReversionStrategy };

package/lib/paradigms/rsi-reversion.js

@@ -0,0 +1,89 @@
+import { rsi } from "@dshtrading/indicators";
+//#region src/paradigms/rsi-reversion.ts
+/**
+* 短周期 RSI 极值均值回归策略（短线，Connors 式）。
+*
+* 入场：RSI(2) < 10 极端超卖入场。
+* 出场：RSI(2) > 60 快速反弹获利了结。
+*/
+const rsiReversionStrategy = {
+	id: "rsi-reversion",
+	horizon: "short",
+	name: "RSI 短线极值回归",
+	summary: "短周期 RSI(2) 进入极端超卖区抄底，快速反弹后止盈（经典均值回归）",
+	params: [
+		{
+			key: "rsiPeriod",
+			label: "RSI 周期",
+			default: 2,
+			min: 2,
+			max: 14,
+			step: 1
+		},
+		{
+			key: "entryThreshold",
+			label: "入场超卖阈值",
+			default: 10,
+			min: 1,
+			max: 30,
+			step: 1
+		},
+		{
+			key: "exitThreshold",
+			label: "出场止盈阈值",
+			default: 60,
+			min: 50,
+			max: 95,
+			step: 1
+		}
+	],
+	compute(bars, params) {
+		const period = Math.max(2, Math.round(params.rsiPeriod ?? 2));
+		const enterThresh = Number(params.entryThreshold ?? 10);
+		const exitThresh = Number(params.exitThreshold ?? 60);
+		const closes = bars.map((b) => b.close);
+		const rsiValues = rsi(closes, period);
+		const signals = [];
+		let inPosition = false;
+		for (let i = 0; i < bars.length; i++) {
+			const val = rsiValues[i];
+			if (val === void 0 || Number.isNaN(val)) continue;
+			if (!inPosition && val < enterThresh) {
+				signals.push({
+					index: i,
+					time: bars[i].openTime,
+					action: "entry",
+					direction: "long",
+					price: bars[i].close,
+					reason: `RSI(${period}) 达到极端超卖值 (${val.toFixed(1)} < ${enterThresh})，触发反弹买入`,
+					reasonKey: "strat.rsi-reversion.reason.entry",
+					reasonParams: {
+						period,
+						val: val.toFixed(1),
+						thresh: enterThresh
+					}
+				});
+				inPosition = true;
+			} else if (inPosition && val > exitThresh) {
+				signals.push({
+					index: i,
+					time: bars[i].openTime,
+					action: "exit",
+					direction: "flat",
+					price: bars[i].close,
+					reason: `RSI(${period}) 回升至目标位 (${val.toFixed(1)} > ${exitThresh})，止盈离场`,
+					reasonKey: "strat.rsi-reversion.reason.exit",
+					reasonParams: {
+						period,
+						val: val.toFixed(1),
+						thresh: exitThresh
+					}
+				});
+				inPosition = false;
+			}
+		}
+		return signals;
+	}
+};
+//#endregion
+export { rsiReversionStrategy };

package/lib/paradigms/sma-baseline.d.ts

@@ -0,0 +1,5 @@
+import { StrategyDefinition } from "../types.js";
+//#region src/paradigms/sma-baseline.d.ts
+declare const smaBaselineStrategy: StrategyDefinition;
+//#endregion
+export { smaBaselineStrategy };