@reefclaw/connect 0.1.0

package/assets/plugin/shared/indicators.js

@@ -0,0 +1,114 @@
+// ⚠️ GENERATED FILE — DO NOT EDIT.
+// Canonical source of truth: shared/src/shared/indicators.ts
+// Regenerate: node scripts/sync-shared-code.mjs  (enforced by shared-code-sync.test.ts)
+//
+// This copy exists because this package builds with tsc and deploys as a
+// self-contained tree that strips workspace deps, so it cannot import
+// @reefclaw/shared runtime code across the deploy boundary.
+// Shared indicator computation helpers.
+// Used by both regime feature engineering and signal condition evaluation.
+export function computeEMA(data, period) {
+    if (data.length < period)
+        return data[data.length - 1] ?? 0;
+    const k = 2 / (period + 1);
+    let ema = mean(data.slice(0, period));
+    for (let i = period; i < data.length; i++) {
+        ema = data[i] * k + ema * (1 - k);
+    }
+    return ema;
+}
+export function computeATR(highs, lows, closes, period) {
+    const series = computeATRSeries(highs, lows, closes, period);
+    return series[series.length - 1] ?? 0;
+}
+export function computeATRSeries(highs, lows, closes, period) {
+    if (highs.length < 2)
+        return [];
+    const tr = [];
+    for (let i = 1; i < highs.length; i++) {
+        tr.push(Math.max(highs[i] - lows[i], Math.abs(highs[i] - closes[i - 1]), Math.abs(lows[i] - closes[i - 1])));
+    }
+    const atr = [];
+    atr[0] = mean(tr.slice(0, period));
+    for (let i = 1; i < tr.length; i++) {
+        atr[i] = (atr[i - 1] * (period - 1) + tr[i]) / period;
+    }
+    return atr;
+}
+export function computeRSI(closes, period) {
+    if (closes.length < period + 1)
+        return 50;
+    const changes = [];
+    for (let i = 1; i < closes.length; i++) {
+        changes.push(closes[i] - closes[i - 1]);
+    }
+    let avgGain = 0;
+    let avgLoss = 0;
+    for (let i = 0; i < period; i++) {
+        if (changes[i] > 0)
+            avgGain += changes[i];
+        else
+            avgLoss -= changes[i];
+    }
+    avgGain /= period;
+    avgLoss /= period;
+    for (let i = period; i < changes.length; i++) {
+        const gain = changes[i] > 0 ? changes[i] : 0;
+        const loss = changes[i] < 0 ? -changes[i] : 0;
+        avgGain = (avgGain * (period - 1) + gain) / period;
+        avgLoss = (avgLoss * (period - 1) + loss) / period;
+    }
+    if (avgLoss === 0)
+        return 100;
+    const rs = avgGain / avgLoss;
+    return 100 - 100 / (1 + rs);
+}
+export function linearSlope(y, x) {
+    const n = y.length;
+    if (n < 2)
+        return 0;
+    const xs = x ?? Array.from({ length: n }, (_, i) => i);
+    const mx = mean(xs);
+    const my = mean(y);
+    let num = 0;
+    let den = 0;
+    for (let i = 0; i < n; i++) {
+        num += (xs[i] - mx) * (y[i] - my);
+        den += (xs[i] - mx) ** 2;
+    }
+    return den > 0 ? num / den : 0;
+}
+export function computeStd(data) {
+    if (data.length < 2)
+        return 0;
+    const avg = mean(data);
+    const variance = data.reduce((s, v) => s + (v - avg) ** 2, 0) / (data.length - 1);
+    return Math.sqrt(variance);
+}
+export function mean(data) {
+    if (data.length === 0)
+        return 0;
+    return data.reduce((s, v) => s + v, 0) / data.length;
+}
+/** Find swing highs and lows from OHLCV bars (simple pivot-point method). */
+export function findSwingPoints(bars, lookback = 5) {
+    const highs = [];
+    const lows = [];
+    for (let i = lookback; i < bars.length - lookback; i++) {
+        let isHigh = true;
+        let isLow = true;
+        for (let j = i - lookback; j <= i + lookback; j++) {
+            if (j === i)
+                continue;
+            if (bars[j].high >= bars[i].high)
+                isHigh = false;
+            if (bars[j].low <= bars[i].low)
+                isLow = false;
+        }
+        if (isHigh)
+            highs.push(bars[i].high);
+        if (isLow)
+            lows.push(bars[i].low);
+    }
+    return { highs, lows };
+}

package/assets/plugin/signals/conditions/registry.d.ts

@@ -0,0 +1,16 @@
+import type { MarketContext, Direction } from '../types.js';
+import type { ConditionFn, ConditionConfig, ConditionContext } from './types.js';
+export declare function getConditionFn(type: string): ConditionFn | undefined;
+export declare function hasCondition(type: string): boolean;
+export declare function listConditionTypes(): string[];
+/** Evaluate an array of condition configs. Returns SignalCondition[] + shared context. */
+export declare function evaluateConditions(configs: ConditionConfig[], ctx: MarketContext, direction: Direction | null): {
+    conditions: Array<{
+        name: string;
+        met: boolean;
+        currentValue: number;
+        threshold: number;
+        description: string;
+    }>;
+    condCtx: ConditionContext;
+};