bitbank-lab-mcp 0.1.0

package/tools/patterns/smoothing.ts

@@ -0,0 +1,168 @@
+/**
+ * patterns/smoothing.ts - 価格データのノイズ除去フィルタ
+ *
+ * Savitzky-Golay フィルタを実装。
+ * TradingPatternScanner (white07S) のアプローチを参考に、
+ * ピボット検出前にhigh/lowデータを平滑化し、誤ピボットを削減する。
+ *
+ * 参考:
+ * - savgol_filter(series, window_length, polyorder=2)
+ * - ウェーブレット系は依存ライブラリが重いため SG に絞る
+ */
+
+/**
+ * Savitzky-Golay フィルタの畳み込み係数を計算する。
+ *
+ * 最小二乗多項式フィッティングに基づくFIRフィルタ。
+ * scipy.signal.savgol_filter と同等のロジック。
+ *
+ * @param windowSize - ウィンドウ幅（奇数）
+ * @param polyOrder  - 多項式の次数（windowSize > polyOrder）
+ * @returns 畳み込み係数の配列（長さ = windowSize）
+ */
+function savgolCoefficients(windowSize: number, polyOrder: number): number[] {
+	const m = Math.floor(windowSize / 2);
+	const order = polyOrder;
+
+	// Vandermonde行列 J を構築 (windowSize × (order+1))
+	// J[i][j] = (i - m)^j  (i = 0..windowSize-1, j = 0..order)
+	const rows = windowSize;
+	const cols = order + 1;
+
+	// J^T * J を計算（cols × cols の正規方程式行列）
+	const JtJ: number[][] = Array.from({ length: cols }, () => Array.from<number>({ length: cols }).fill(0));
+	for (let j1 = 0; j1 < cols; j1++) {
+		for (let j2 = j1; j2 < cols; j2++) {
+			let sum = 0;
+			for (let i = 0; i < rows; i++) {
+				const x = i - m;
+				sum += x ** j1 * x ** j2;
+			}
+			JtJ[j1][j2] = sum;
+			JtJ[j2][j1] = sum;
+		}
+	}
+
+	// (J^T * J)^{-1} を Gauss-Jordan 法で求める
+	const aug: number[][] = JtJ.map((row, i) => {
+		const extended = Array.from<number>({ length: 2 * cols }).fill(0);
+		for (let j = 0; j < cols; j++) extended[j] = row[j];
+		extended[cols + i] = 1;
+		return extended;
+	});
+
+	for (let col = 0; col < cols; col++) {
+		// ピボット選択
+		let maxRow = col;
+		let maxVal = Math.abs(aug[col][col]);
+		for (let row = col + 1; row < cols; row++) {
+			if (Math.abs(aug[row][col]) > maxVal) {
+				maxVal = Math.abs(aug[row][col]);
+				maxRow = row;
+			}
+		}
+		if (maxRow !== col) {
+			[aug[col], aug[maxRow]] = [aug[maxRow], aug[col]];
+		}
+
+		const pivot = aug[col][col];
+		if (Math.abs(pivot) < 1e-15) continue;
+
+		for (let j = 0; j < 2 * cols; j++) aug[col][j] /= pivot;
+
+		for (let row = 0; row < cols; row++) {
+			if (row === col) continue;
+			const factor = aug[row][col];
+			for (let j = 0; j < 2 * cols; j++) {
+				aug[row][j] -= factor * aug[col][j];
+			}
+		}
+	}
+
+	// 逆行列を抽出
+	const inv: number[][] = aug.map((row) => row.slice(cols));
+
+	// 係数 = (J^T J)^{-1} J^T の第0行（平滑化＝0次の係数）
+	// c[i] = sum_j inv[0][j] * (i - m)^j
+	const coeffs = Array.from<number>({ length: windowSize }).fill(0);
+	for (let i = 0; i < windowSize; i++) {
+		const x = i - m;
+		let val = 0;
+		for (let j = 0; j < cols; j++) {
+			val += inv[0][j] * x ** j;
+		}
+		coeffs[i] = val;
+	}
+
+	return coeffs;
+}
+
+/**
+ * Savitzky-Golay フィルタを1次元配列に適用する。
+ *
+ * @param data       - 入力データ
+ * @param windowSize - ウィンドウ幅（奇数, デフォルト 5）
+ * @param polyOrder  - 多項式次数（デフォルト 2 = 2次多項式）
+ * @returns 平滑化されたデータ（元と同じ長さ）
+ */
+export function savgolFilter(data: number[], windowSize: number = 5, polyOrder: number = 2): number[] {
+	const n = data.length;
+	if (n === 0) return [];
+
+	// ウィンドウサイズを奇数に強制
+	let ws = Math.max(3, windowSize);
+	if (ws % 2 === 0) ws += 1;
+	// polyOrder < windowSize を保証
+	const po = Math.min(polyOrder, ws - 1);
+
+	if (n < ws) {
+		// データがウィンドウより短い場合はそのまま返す
+		return [...data];
+	}
+
+	const coeffs = savgolCoefficients(ws, po);
+	const half = Math.floor(ws / 2);
+	const result = Array.from<number>({ length: n });
+
+	// 中央部分: 畳み込み
+	for (let i = half; i < n - half; i++) {
+		let sum = 0;
+		for (let j = 0; j < ws; j++) {
+			sum += coeffs[j] * data[i - half + j];
+		}
+		result[i] = sum;
+	}
+
+	// 端の処理: 元データをそのまま使用（境界効果の回避）
+	for (let i = 0; i < half; i++) {
+		result[i] = data[i];
+	}
+	for (let i = n - half; i < n; i++) {
+		result[i] = data[i];
+	}
+
+	return result;
+}
+
+/**
+ * ローソク足の high/low 系列にSGフィルタを適用する。
+ * 元のローソク足データは変更せず、平滑化された high/low 配列を返す。
+ *
+ * @param candles - ローソク足データ
+ * @param windowSize - SGフィルタのウィンドウ幅（奇数）
+ * @param polyOrder  - 多項式次数
+ * @returns { smoothHigh, smoothLow } 平滑化されたhigh/low配列
+ */
+export function smoothCandleExtremes(
+	candles: Array<{ high: number; low: number }>,
+	windowSize: number = 5,
+	polyOrder: number = 2,
+): { smoothHigh: number[]; smoothLow: number[] } {
+	const highs = candles.map((c) => c.high);
+	const lows = candles.map((c) => c.low);
+
+	return {
+		smoothHigh: savgolFilter(highs, windowSize, polyOrder),
+		smoothLow: savgolFilter(lows, windowSize, polyOrder),
+	};
+}

package/tools/patterns/swing.ts

@@ -0,0 +1,91 @@
+/**
+ * patterns/swing.ts - スイングポイント（ピボット）検出
+ *
+ * ローソク足データからスイングハイ/スイングローを検出する。
+ */
+
+/** ローソク足の最小インターフェース */
+export interface Candle {
+	open: number;
+	close: number;
+	high: number;
+	low: number;
+	isoTime?: string;
+}
+
+/** スイングポイント（ピボット） */
+export interface Pivot {
+	idx: number;
+	price: number;
+	kind: 'H' | 'L';
+}
+
+export interface DetectSwingePointsOptions {
+	/** スイング検出の深さ（前後何本を比較するか） */
+	swingDepth: number;
+	/** 厳格モード: 全ての前後バーより高い/低い必要がある（false: 60%投票制） */
+	strictPivots?: boolean;
+}
+
+/**
+ * ローソク足データからスイングポイント（ピボット）を検出する
+ *
+ * @param candles - ローソク足データ
+ * @param options - 検出オプション
+ * @returns 検出されたピボットの配列
+ */
+export function detectSwingPoints(candles: Candle[], options: DetectSwingePointsOptions): Pivot[] {
+	const { swingDepth, strictPivots = true } = options;
+
+	const highs = candles.map((c) => c.high);
+	const lows = candles.map((c) => c.low);
+	const pivots: Pivot[] = [];
+
+	for (let i = swingDepth; i < candles.length - swingDepth; i++) {
+		let isHigh = true;
+		let isLow = true;
+
+		if (strictPivots) {
+			// 厳格モード: 全ての前後バーより高い/低い必要がある
+			for (let k = 1; k <= swingDepth; k++) {
+				if (!(highs[i] > highs[i - k] && highs[i] > highs[i + k])) isHigh = false;
+				if (!(lows[i] < lows[i - k] && lows[i] < lows[i + k])) isLow = false;
+				if (!isHigh && !isLow) break;
+			}
+		} else {
+			// 緩和モード: 60%投票制
+			let votesHigh = 0;
+			let votesLow = 0;
+			for (let k = 1; k <= swingDepth; k++) {
+				votesHigh += highs[i] > highs[i - k] && highs[i] > highs[i + k] ? 1 : 0;
+				votesLow += lows[i] < lows[i - k] && lows[i] < lows[i + k] ? 1 : 0;
+			}
+			const need = Math.ceil(swingDepth * 0.6);
+			isHigh = votesHigh >= need;
+			isLow = votesLow >= need;
+		}
+
+		// 判定は high/low、格納価格は close（ヒゲ影響を回避）
+		if (isHigh) {
+			pivots.push({ idx: i, price: candles[i].close, kind: 'H' });
+		} else if (isLow) {
+			pivots.push({ idx: i, price: candles[i].close, kind: 'L' });
+		}
+	}
+
+	return pivots;
+}
+
+/**
+ * ピボットを高値（H）のみにフィルタリング
+ */
+export function filterPeaks(pivots: Pivot[]): Pivot[] {
+	return pivots.filter((p) => p.kind === 'H');
+}
+
+/**
+ * ピボットを安値（L）のみにフィルタリング
+ */
+export function filterValleys(pivots: Pivot[]): Pivot[] {
+	return pivots.filter((p) => p.kind === 'L');
+}

package/tools/patterns/types.ts

@@ -0,0 +1,193 @@
+/**
+ * detect_patterns 系モジュール共通の型定義
+ */
+import type { Pivot } from './swing.js';
+
+/** トレンドライン（線形回帰の結果） */
+export interface TrendLine {
+	slope: number;
+	intercept: number;
+	r2?: number;
+	valueAt: (x: number) => number;
+}
+
+/** ウェッジ検出パラメータ */
+export interface WedgeParams {
+	minSlope?: number;
+	slopeRatioMinRising?: number;
+	slopeRatioMinFalling?: number;
+	slopeRatioMin?: number;
+	minWeakerSlopeRatio?: number;
+	windowSizeMin?: number;
+	windowSizeMax?: number;
+}
+
+/** パターンスコアの各構成要素 */
+export interface PatternScoreComponents {
+	fitScore: number;
+	convergeScore: number;
+	touchScore: number;
+	alternationScore: number;
+	insideScore: number;
+	durationScore: number;
+}
+
+/** パターンスコアの重み */
+export interface PatternScoreWeights {
+	fit: number;
+	converge: number;
+	touch: number;
+	alternation: number;
+	inside: number;
+	duration: number;
+}
+
+/** タッチポイント */
+export interface TouchPoint {
+	index: number;
+	distance: number;
+	isBreak: boolean;
+}
+
+/** evaluateTouchesEx の戻り値 */
+export interface TouchResult {
+	upperTouches: TouchPoint[];
+	lowerTouches: TouchPoint[];
+	upperQuality: number;
+	lowerQuality: number;
+	score: number;
+}
+
+/** 重複排除対象のパターンエントリ（最低限のフィールド + 任意の追加フィールド） */
+export interface DeduplicablePattern {
+	type?: string;
+	confidence?: number;
+	range?: { start: string; end: string; current?: string };
+	pivots?: Array<{ idx?: number; price?: number; kind?: string }>;
+	[key: string]: unknown;
+}
+
+/** ローソク足データ（detectSwingPoints 互換） */
+export interface CandleData {
+	open: number;
+	close: number;
+	high: number;
+	low: number;
+	isoTime?: string;
+}
+
+/** pushCand() に渡すデバッグ引数 */
+export interface CandDebugArg {
+	type: string;
+	accepted: boolean;
+	reason?: string;
+	idxs?: number[];
+	pts?: Array<{ role: string; idx: number; price: number }>;
+}
+
+/** debugCandidates 配列の要素 */
+export interface CandDebugEntry {
+	type: string;
+	accepted: boolean;
+	reason?: string;
+	indices?: number[];
+	points?: Array<{ role: string; idx: number; price: number; isoTime?: string }>;
+	details?: unknown;
+	status?: string;
+	breakoutDirection?: string | null;
+}
+
+/**
+ * パターン検出コンテキスト — 各検出モジュールが共有するデータとコンフィグ。
+ * detectPatterns() が組み立てて各検出関数に渡す。
+ */
+export interface DetectContext {
+	candles: CandleData[];
+	pivots: Pivot[];
+	allPeaks: Pivot[];
+	allValleys: Pivot[];
+	tolerancePct: number;
+	minDist: number;
+	/** 検出対象パターン種別。空 = 全種 */
+	want: Set<string>;
+	includeForming: boolean;
+	/** デバッグ候補バッファ（各モジュールが直接 push する） */
+	debugCandidates: CandDebugEntry[];
+	/** 時間軸（'1day', '1hour', '1week' 等） */
+	type: string;
+	/** スイング深度 */
+	swingDepth: number;
+	/** 近接判定ヘルパー（tolerancePct ベース） */
+	near: (a: number, b: number) => boolean;
+	/** 変化率計算 */
+	pct: (a: number, b: number) => number;
+	/** R² 付き線形回帰 */
+	lrWithR2: (pts: Array<{ x: number; y: number }>) => {
+		slope: number;
+		intercept: number;
+		r2: number;
+		valueAt: (x: number) => number;
+	};
+}
+
+/** 各パターン検出関数の戻り値 */
+export interface DetectResult {
+	patterns: PatternEntry[];
+	/** 検出成否フラグ（後続の relaxed パスに使用） */
+	found?: Record<string, boolean>;
+}
+
+/** 事後分析結果 */
+export interface AftermathResult {
+	breakoutDate?: string | null;
+	breakoutConfirmed: boolean;
+	priceMove?: Record<string, { return: number; high: number; low: number } | null>;
+	targetReached: boolean;
+	theoreticalTarget?: number | null;
+	outcome: string;
+	daysToTarget?: number | null;
+}
+
+/** パターンエントリ（検出結果の1件）— 共通フィールド＋任意拡張 */
+export interface PatternEntry extends DeduplicablePattern {
+	confidence?: number;
+	timeframe?: string;
+	timeframeLabel?: string;
+	neckline?: Array<{ x?: number; y: number }>;
+	structureDiagram?: { svg: string; artifact?: { identifier: string; title: string } };
+	status?: string;
+	breakout?: { idx: number; price: number; direction?: string } | null;
+	breakoutDirection?: 'up' | 'down';
+	outcome?: 'success' | 'failure' | string;
+	breakoutTarget?: number;
+	targetMethod?: string;
+	targetReachedPct?: number;
+	trendlineLabel?: string;
+	poleDirection?: 'up' | 'down';
+	priorTrendDirection?: 'bullish' | 'bearish';
+	flagpoleHeight?: number;
+	retracementRatio?: number;
+	isTrendContinuation?: boolean;
+	apexDate?: string;
+	daysToApex?: number;
+	completionPct?: number;
+	breakoutDate?: string;
+	breakoutBarIndex?: number;
+	daysSinceBreakout?: number;
+	aftermath?: AftermathResult | null;
+}
+
+/** pushCand ヘルパー（デバッグ候補に isoTime を付加して追加） */
+export function pushCand(ctx: DetectContext, arg: CandDebugArg): void {
+	const points = (arg.pts || []).map((p) => ({
+		...p,
+		isoTime: (ctx.candles[p.idx] as CandleData | undefined)?.isoTime,
+	}));
+	ctx.debugCandidates.push({
+		type: arg.type,
+		accepted: arg.accepted,
+		reason: arg.reason,
+		indices: arg.idxs,
+		points,
+	});
+}