stock-analyzer-skill 1.1.0

package/scripts/technical/candlestick.py

@@ -0,0 +1,151 @@
+"""
+K 线形态识别。
+依赖: core (to_float via common)
+"""
+from common import to_float
+
+
+def detect_candle_patterns(records):
+    """识别最近 4 根 K 线的形态。"""
+    if len(records) < 4:
+        return []
+
+    patterns = []
+    bars = []
+    for r in records[-4:]:
+        bars.append({
+            "open": to_float(r.get("open")),
+            "high": to_float(r.get("high")),
+            "low": to_float(r.get("low")),
+            "close": to_float(r.get("close")),
+            "date": r.get("day", ""),
+        })
+
+    # 单根形态（最近3根）
+    for i, b in enumerate(bars[-3:]):
+        idx = len(bars) - 3 + i
+        prev_close = bars[idx - 1]["close"] if idx > 0 else b["open"]
+        singles = _candle_single(b, prev_close)
+        for s in singles:
+            patterns.append({"date": b["date"], "type": s, "position": f"T-{len(bars)-1-idx}"})
+
+    # A 股特化形态
+    if len(bars) >= 2:
+        ah = _candle_ashare(bars[-2], bars[-1])
+        if ah:
+            patterns.append({"date": bars[-1]["date"], "type": ah, "position": "T-0"})
+
+    # 双根组合
+    if len(bars) >= 2:
+        doubles = _candle_double(bars[-2], bars[-1])
+        for d in doubles:
+            patterns.append({"date": bars[-1]["date"], "type": d, "position": "T-1~0"})
+
+    # 三根组合
+    if len(bars) >= 3:
+        triples = _candle_triple(bars[-3], bars[-2], bars[-1])
+        for t in triples:
+            patterns.append({"date": bars[-1]["date"], "type": t, "position": "T-2~0"})
+
+    return patterns
+
+
+def _body_shadow(bar):
+    """计算实体、上影线、下影线。"""
+    body = abs(bar["close"] - bar["open"])
+    upper_shadow = bar["high"] - max(bar["close"], bar["open"])
+    lower_shadow = min(bar["close"], bar["open"]) - bar["low"]
+    total = bar["high"] - bar["low"]
+    return body, upper_shadow, lower_shadow, total
+
+
+def _is_bullish(bar):
+    return bar["close"] > bar["open"]
+
+
+def _candle_single(bar, prev_close):
+    """单根 K 线形态识别。"""
+    body, upper, lower, total = _body_shadow(bar)
+    if total <= 0:
+        return []
+    patterns = []
+
+    # 十字星
+    if body / total < 0.1:
+        patterns.append("十字星(变盘信号)")
+    # 锤子线
+    elif lower > 2 * body and (bar["high"] - bar["close"]) < body:
+        patterns.append("锤子线(底部反转)")
+    # 倒锤子
+    elif upper > 2 * body and (bar["close"] - bar["low"]) < body:
+        patterns.append("倒锤子(可能见顶)")
+    # 光头光脚阳线
+    elif _is_bullish(bar) and bar["close"] == bar["high"] and bar["open"] == bar["low"]:
+        patterns.append("光头光脚阳线(强势)")
+    # 光头光脚阴线
+    elif not _is_bullish(bar) and bar["open"] == bar["high"] and bar["close"] == bar["low"]:
+        patterns.append("光头光脚阴线(弱势)")
+    # T 字线
+    elif body / total < 0.05 and upper < body and lower > 3 * body:
+        patterns.append("T字线(下方支撑强)")
+    # 倒 T 字
+    elif body / total < 0.05 and lower < body and upper > 3 * body:
+        patterns.append("倒T字(上方压力大)")
+
+    return patterns
+
+
+def _candle_ashare(prev, curr):
+    """A 股特化形态。"""
+    if _is_bullish(curr):
+        if curr["close"] < prev["close"]:
+            return "假阳真阴(收阳但实际下跌)"
+    else:
+        if curr["close"] > prev["close"]:
+            return "假阴真阳(收阴但实际上涨)"
+    return None
+
+
+def _candle_double(b1, b2):
+    """双根 K 线组合。"""
+    patterns = []
+    # 阳包阴
+    if not _is_bullish(b1) and _is_bullish(b2) and b2["close"] > b1["open"] and b2["open"] < b1["close"]:
+        patterns.append("阳包阴(看涨吞没)")
+    # 阴包阳
+    if _is_bullish(b1) and not _is_bullish(b2) and b2["close"] < b1["open"] and b2["open"] > b1["close"]:
+        patterns.append("阴包阳(看跌吞没)")
+    # 平底/平顶
+    if abs(b1["low"] - b2["low"]) / max(b1["low"], 0.01) < 0.005:
+        patterns.append("平底(支撑确认)")
+    if abs(b1["high"] - b2["high"]) / max(b1["high"], 0.01) < 0.005:
+        patterns.append("平顶(压力确认)")
+    # 揉搓线：一长上影一长下影
+    body1, upper1, lower1, _ = _body_shadow(b1)
+    body2, upper2, lower2, _ = _body_shadow(b2)
+    if (upper1 > 2 * body1 and lower2 > 2 * body2) or (lower1 > 2 * body1 and upper2 > 2 * body2):
+        patterns.append("揉搓线(洗盘或变盘)")
+    return patterns
+
+
+def _candle_triple(b1, b2, b3):
+    """三根 K 线组合。"""
+    patterns = []
+    body1, _, _, _ = _body_shadow(b1)
+    body2, _, _, _ = _body_shadow(b2)
+    body3, _, _, _ = _body_shadow(b3)
+
+    # 早晨之星：阴线 + 小实体 + 阳线
+    if not _is_bullish(b1) and body2 < body1 * 0.5 and _is_bullish(b3) and b3["close"] > (b1["open"] + b1["close"]) / 2:
+        patterns.append("早晨之星(底部反转)")
+    # 黄昏之星：阳线 + 小实体 + 阴线
+    if _is_bullish(b1) and body2 < body1 * 0.5 and not _is_bullish(b3) and b3["close"] < (b1["open"] + b1["close"]) / 2:
+        patterns.append("黄昏之星(顶部反转)")
+    # 红三兵
+    if _is_bullish(b1) and _is_bullish(b2) and _is_bullish(b3) and b1["close"] < b2["close"] < b3["close"]:
+        if b2["open"] > b1["open"] and b3["open"] > b2["open"]:
+            patterns.append("红三兵(强势延续)")
+    # 三只乌鸦
+    if not _is_bullish(b1) and not _is_bullish(b2) and not _is_bullish(b3) and b1["close"] > b2["close"] > b3["close"]:
+        patterns.append("三只乌鸦(弱势延续)")
+    return patterns

package/scripts/technical/core.py

@@ -0,0 +1,92 @@
+"""
+核心数学工具和数据解析。
+无内部依赖，仅使用标准库。
+"""
+import math
+import statistics
+
+from common import to_float
+
+
+# ═══════════════════════════════════════════════════════════════
+# 数学工具
+# ═══════════════════════════════════════════════════════════════
+
+
+def sma(values, period):
+    """简单移动平均。"""
+    if len(values) < period:
+        return statistics.mean(values) if values else 0
+    return statistics.mean(values[-period:])
+
+
+def ema(values, period):
+    """指数移动平均。"""
+    if len(values) < period:
+        return statistics.mean(values) if values else 0
+    k = 2 / (period + 1)
+    result = statistics.mean(values[:period])
+    for v in values[period:]:
+        result = v * k + result * (1 - k)
+    return result
+
+
+def _ema_series(values, period):
+    """返回 EMA 序列（用于背离检测和 KDJ）。"""
+    if len(values) < period:
+        return []
+    k = 2 / (period + 1)
+    result = [statistics.mean(values[:period])]
+    for v in values[period:]:
+        result.append(v * k + result[-1] * (1 - k))
+    return result
+
+
+def stddev(values):
+    """总体标准差。"""
+    if len(values) < 2:
+        return 0
+    mean = statistics.mean(values)
+    return math.sqrt(sum((x - mean) ** 2 for x in values) / len(values))
+
+
+def _find_swing_points(values, window=5):
+    """找局部极值点索引列表。用于背离检测。"""
+    if len(values) < 2 * window + 1:
+        return [], []
+    highs, lows = [], []
+    for i in range(window, len(values) - window):
+        left = values[i - window:i]
+        right = values[i + 1:i + window + 1]
+        if values[i] >= max(left) and values[i] > max(right):
+            highs.append(i)
+        if values[i] <= min(left) and values[i] < min(right):
+            lows.append(i)
+    return highs, lows
+
+
+# ═══════════════════════════════════════════════════════════════
+# 数据解析
+# ═══════════════════════════════════════════════════════════════
+
+
+def _parse_records(records):
+    """将 K 线数据转成数值列表（统一过滤零值，保持数组对齐）。"""
+    # 先过滤掉任一字段为 0 的整条记录，确保所有数组索引对齐
+    valid_records = []
+    for r in records:
+        c = to_float(r.get("close"))
+        o = to_float(r.get("open"))
+        h = to_float(r.get("high"))
+        lo = to_float(r.get("low"))
+        v = to_float(r.get("volume"))
+        if c > 0 and o > 0 and h > 0 and lo > 0 and v > 0:
+            valid_records.append(r)
+
+    closes = [to_float(r.get("close")) for r in valid_records]
+    opens = [to_float(r.get("open")) for r in valid_records]
+    highs = [to_float(r.get("high")) for r in valid_records]
+    lows = [to_float(r.get("low")) for r in valid_records]
+    volumes = [to_float(r.get("volume")) for r in valid_records]
+
+    return closes, opens, highs, lows, volumes

package/scripts/technical/kdj.py

@@ -0,0 +1,68 @@
+"""
+KDJ 指标（含钝化检测）。
+无内部依赖。
+"""
+
+
+def kdj_full(closes, highs, lows, n=9):
+    """KDJ 指标 + 钝化检测。"""
+    if len(closes) < n + 1:
+        return None
+
+    # 计算 KDJ 序列
+    k_series, d_series = [], []
+    k_val, d_val = 50, 50
+    for i in range(n - 1, len(closes)):
+        low_n = min(lows[i - n + 1:i + 1])
+        high_n = max(highs[i - n + 1:i + 1])
+        rsv = ((closes[i] - low_n) / (high_n - low_n) * 100) if high_n != low_n else 50
+        k_val = 2 / 3 * k_val + 1 / 3 * rsv
+        d_val = 2 / 3 * d_val + 1 / 3 * k_val
+        k_series.append(k_val)
+        d_series.append(d_val)
+
+    k_now = k_series[-1]
+    d_now = d_series[-1]
+    j_now = 3 * k_now - 2 * d_now
+
+    # 金叉死叉
+    kdj_signal = "正常"
+    if len(k_series) >= 2:
+        if k_series[-2] <= d_series[-2] and k_now > d_now:
+            kdj_signal = "金叉"
+        elif k_series[-2] >= d_series[-2] and k_now < d_now:
+            kdj_signal = "死叉"
+
+    # 超买超卖区（附加信息，不覆盖金叉/死叉）
+    zone = ""
+    if j_now > 100:
+        zone = f"超买区(J={j_now:.0f})"
+    elif j_now < 0:
+        zone = f"超卖区(J={j_now:.0f})"
+
+    # 组合信号：金叉+超卖 或 死叉+超买
+    if zone:
+        if kdj_signal == "金叉" and j_now < 0:
+            kdj_signal = "金叉+超卖"
+        elif kdj_signal == "死叉" and j_now > 100:
+            kdj_signal = "死叉+超买"
+        elif kdj_signal == "正常":
+            kdj_signal = zone
+
+    # A 股特化：KDJ 钝化检测
+    dunhua = False
+    if len(k_series) >= 5:
+        if all(k > 80 for k in k_series[-5:]):
+            dunhua = True
+            kdj_signal += " [KDJ高位钝化-趋势延续]"
+        elif all(k < 20 for k in k_series[-5:]):
+            dunhua = True
+            kdj_signal += " [KDJ低位钝化-趋势延续]"
+
+    return {
+        "k": round(k_now, 2),
+        "d": round(d_now, 2),
+        "j": round(j_now, 2),
+        "signal": kdj_signal,
+        "钝化": dunhua,
+    }

package/scripts/technical/macd.py

@@ -0,0 +1,97 @@
+"""
+MACD 指标（含背离检测）。
+依赖: core (ema, _ema_series, _find_swing_points)
+"""
+from .core import ema, _ema_series, _find_swing_points
+
+
+def macd_full(closes):
+    """MACD 完整分析：DIF/DEA/柱/金叉死叉 + 顶背离/底背离。"""
+    if len(closes) < 34:
+        return None
+
+    # DIF/DEA
+    ema12 = ema(closes, 12)
+    ema26 = ema(closes, 26)
+    dif = ema12 - ema26
+
+    # 计算 DIF 序列
+    ema12_series = _ema_series(closes, 12)
+    ema26_series = _ema_series(closes, 26)
+    min_len = min(len(ema12_series), len(ema26_series))
+    dif_series = [ema12_series[i] - ema26_series[i] for i in range(min_len)]
+
+    dea_series = _ema_series(dif_series, 9)
+    dea = dea_series[-1] if dea_series else dif
+    prev_dif = dif_series[-2] if len(dif_series) >= 2 else dif
+    prev_dea = dea_series[-2] if len(dea_series) >= 2 else dea
+    macd_bar = (dif - dea) * 2
+
+    # 金叉死叉检测
+    signal = 0
+    if prev_dif <= prev_dea and dif > dea:
+        signal = 1
+    elif prev_dif >= prev_dea and dif < dea:
+        signal = -1
+
+    # 柱状图趋势
+    prev_bar = (prev_dif - prev_dea) * 2
+    if macd_bar > 0 and macd_bar > prev_bar:
+        bar_trend = "红柱放大"
+    elif macd_bar > 0 and macd_bar <= prev_bar:
+        bar_trend = "红柱缩小"
+    elif macd_bar < 0 and macd_bar < prev_bar:
+        bar_trend = "绿柱放大"
+    else:
+        bar_trend = "绿柱缩小"
+
+    # 背离检测
+    divergence = _detect_macd_divergence(closes, dif_series, dea_series)
+
+    return {
+        "dif": round(dif, 4),
+        "dea": round(dea, 4),
+        "macd_bar": round(macd_bar, 4),
+        "signal": signal,
+        "signal_desc": {1: "金叉", -1: "死叉", 0: "无"}.get(signal),
+        "bar_trend": bar_trend,
+        "divergence": divergence,
+    }
+
+
+def _detect_macd_divergence(closes, dif_series, dea_series):
+    """检测 MACD 顶背离/底背离。"""
+    if len(closes) < 60 or len(dif_series) < 60:
+        return None
+
+    lookback = min(60, len(closes))
+    c = closes[-lookback:]
+    d = dif_series[-lookback:]
+
+    price_highs, price_lows = _find_swing_points(c, window=5)
+    dif_highs, dif_lows = _find_swing_points(d, window=5)
+
+    # 顶背离：价格新高而 DIF 未新高
+    if len(price_highs) >= 2:
+        last2_p = sorted(price_highs[-2:])
+        if last2_p[1] - last2_p[0] >= 8:
+            if c[last2_p[1]] > c[last2_p[0]]:
+                # 找到对应的 DIF 峰值
+                relevant_dif_peaks = [i for i in dif_highs if abs(i - last2_p[0]) <= 5 or abs(i - last2_p[1]) <= 5]
+                if len(relevant_dif_peaks) >= 2:
+                    relevant_dif_peaks.sort()
+                    if d[relevant_dif_peaks[-1]] < d[relevant_dif_peaks[0]]:
+                        return "顶背离(看跌)"
+
+    # 底背离：价格新低而 DIF 未新低
+    if len(price_lows) >= 2:
+        last2_p = sorted(price_lows[-2:])
+        if last2_p[1] - last2_p[0] >= 8:
+            if c[last2_p[1]] < c[last2_p[0]]:
+                relevant_dif_lows = [i for i in dif_lows if abs(i - last2_p[0]) <= 5 or abs(i - last2_p[1]) <= 5]
+                if len(relevant_dif_lows) >= 2:
+                    relevant_dif_lows.sort()
+                    if d[relevant_dif_lows[-1]] > d[relevant_dif_lows[0]]:
+                        return "底背离(看涨)"
+
+    return None

package/scripts/technical/moving_average.py

@@ -0,0 +1,59 @@
+"""
+均线系统分析。
+依赖: core (sma, stddev)
+"""
+import statistics
+
+from .core import sma, stddev
+
+
+_MA_PERIODS = [5, 10, 20, 60, 120, 250]
+
+
+def ma_system(closes):
+    """均线系统分析。返回 MA 值、排列状态、粘合度、支撑/阻力均线。"""
+    result = {}
+    for p in _MA_PERIODS:
+        result[f"ma{p}"] = round(sma(closes, p), 2) if len(closes) >= p else None
+
+    # 排列状态
+    mas = [result[f"ma{p}"] for p in _MA_PERIODS if result[f"ma{p}"] is not None]
+    if len(mas) >= 4:
+        if all(mas[i] > mas[i+1] for i in range(len(mas)-1) if mas[i] and mas[i+1]):
+            result["alignment"] = "多头排列"
+        elif all(mas[i] < mas[i+1] for i in range(len(mas)-1) if mas[i] and mas[i+1]):
+            result["alignment"] = "空头排列"
+        else:
+            result["alignment"] = "交叉震荡"
+    else:
+        result["alignment"] = "数据不足"
+
+    # MA 粘合度 (MA5/10/20)
+    short_mas = [result.get(f"ma{p}") for p in [5, 10, 20] if result.get(f"ma{p}")]
+    if len(short_mas) >= 3 and statistics.mean(short_mas) > 0:
+        conv = stddev(short_mas) / statistics.mean(short_mas)
+        result["convergence"] = round(conv, 4)
+        if conv < 0.02:
+            result["convergence_desc"] = "高度粘合(变盘窗口)"
+        elif conv < 0.05:
+            result["convergence_desc"] = "中度粘合"
+        else:
+            result["convergence_desc"] = "发散"
+    else:
+        result["convergence"] = None
+        result["convergence_desc"] = "数据不足"
+
+    # 支撑/阻力均线（相对当前价格）
+    last = closes[-1] if closes else 0
+    supports, resistances = [], []
+    for p in _MA_PERIODS:
+        v = result.get(f"ma{p}")
+        if v is None:
+            continue
+        if v < last:
+            supports.append((f"MA{p}", v))
+        else:
+            resistances.append((f"MA{p}", v))
+    result["ma_supports"] = sorted(supports, key=lambda x: x[1], reverse=True)
+    result["ma_resistances"] = sorted(resistances, key=lambda x: x[1])
+    return result