beast-agent 2.32.0 → 2.33.1

package/src/agent/finindicators.js

@@ -0,0 +1,254 @@
+'use strict';
+
+/* Beast Finance — teknik gösterge matematiği (saf JS, bağımlılıksız).
+   mt5_rates'in döndürdüğü OHLC dizilerinden EMA/SMA/RSI/ATR/MACD/BB/Stoch
+   hesaplar. UI veya köprü gerektirmez; birim testleri doğrudan bu modülü çağırır. */
+
+function nums(arr) {
+  return (Array.isArray(arr) ? arr : []).map((v) => {
+    const n = Number(v);
+    return isFinite(n) ? n : NaN;
+  });
+}
+
+function smaSeries(values, period) {
+  const v = nums(values);
+  const out = new Array(v.length).fill(null);
+  const p = Math.max(1, Math.round(Number(period) || 1));
+  if (v.length < p) return out;
+  let sum = 0;
+  for (let i = 0; i < v.length; i++) {
+    sum += v[i];
+    if (i >= p) sum -= v[i - p];
+    if (i >= p - 1) out[i] = sum / p;
+  }
+  return out;
+}
+
+function emaSeries(values, period) {
+  const v = nums(values);
+  const out = new Array(v.length).fill(null);
+  const p = Math.max(1, Math.round(Number(period) || 1));
+  if (v.length < p) return out;
+  const k = 2 / (p + 1);
+  let sum = 0;
+  for (let i = 0; i < p; i++) sum += v[i];
+  let prev = sum / p;
+  out[p - 1] = prev;
+  for (let i = p; i < v.length; i++) {
+    prev = v[i] * k + prev * (1 - k);
+    out[i] = prev;
+  }
+  return out;
+}
+
+/* Wilder RSI — ilk ortalama SMA, sonrası Wilder yumuşatması */
+function rsiSeries(closes, period) {
+  const c = nums(closes);
+  const p = Math.max(2, Math.round(Number(period) || 14));
+  const out = new Array(c.length).fill(null);
+  if (c.length <= p) return out;
+  let gain = 0;
+  let loss = 0;
+  for (let i = 1; i <= p; i++) {
+    const d = c[i] - c[i - 1];
+    if (d >= 0) gain += d;
+    else loss -= d;
+  }
+  let avgGain = gain / p;
+  let avgLoss = loss / p;
+  out[p] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
+  for (let i = p + 1; i < c.length; i++) {
+    const d = c[i] - c[i - 1];
+    const g = d > 0 ? d : 0;
+    const l = d < 0 ? -d : 0;
+    avgGain = (avgGain * (p - 1) + g) / p;
+    avgLoss = (avgLoss * (p - 1) + l) / p;
+    out[i] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
+  }
+  return out;
+}
+
+function trueRanges(highs, lows, closes) {
+  const h = nums(highs);
+  const l = nums(lows);
+  const c = nums(closes);
+  const out = new Array(c.length).fill(NaN);
+  for (let i = 0; i < c.length; i++) {
+    const prev = i > 0 ? c[i - 1] : c[i];
+    out[i] = Math.max(h[i] - l[i], Math.abs(h[i] - prev), Math.abs(l[i] - prev));
+  }
+  return out;
+}
+
+/* Wilder ATR */
+function atrSeries(highs, lows, closes, period) {
+  const tr = trueRanges(highs, lows, closes);
+  const p = Math.max(1, Math.round(Number(period) || 14));
+  const out = new Array(tr.length).fill(null);
+  if (tr.length < p) return out;
+  let sum = 0;
+  for (let i = 0; i < p; i++) sum += tr[i];
+  let prev = sum / p;
+  out[p - 1] = prev;
+  for (let i = p; i < tr.length; i++) {
+    prev = (prev * (p - 1) + tr[i]) / p;
+    out[i] = prev;
+  }
+  return out;
+}
+
+function macdSeries(closes, fast, slow, signalPeriod) {
+  const f = Math.max(1, Math.round(Number(fast) || 12));
+  const s = Math.max(2, Math.round(Number(slow) || 26));
+  const sig = Math.max(1, Math.round(Number(signalPeriod) || 9));
+  const emaFast = emaSeries(closes, f);
+  const emaSlow = emaSeries(closes, s);
+  const macd = emaFast.map((v, i) => (v == null || emaSlow[i] == null ? null : v - emaSlow[i]));
+  const start = macd.findIndex((v) => v != null);
+  const compact = start >= 0 ? macd.slice(start) : [];
+  const signalCompact = emaSeries(compact, sig);
+  const signal = new Array(macd.length).fill(null);
+  if (start >= 0) {
+    for (let i = 0; i < signalCompact.length; i++) signal[start + i] = signalCompact[i];
+  }
+  const hist = macd.map((v, i) => (v == null || signal[i] == null ? null : v - signal[i]));
+  return { macd, signal, hist };
+}
+
+function bollingerSeries(closes, period, mult) {
+  const c = nums(closes);
+  const p = Math.max(2, Math.round(Number(period) || 20));
+  const m = Number(mult) > 0 ? Number(mult) : 2;
+  const mid = smaSeries(c, p);
+  const upper = new Array(c.length).fill(null);
+  const lower = new Array(c.length).fill(null);
+  for (let i = p - 1; i < c.length; i++) {
+    let sum = 0;
+    for (let j = i - p + 1; j <= i; j++) sum += Math.pow(c[j] - mid[i], 2);
+    const sd = Math.sqrt(sum / p);
+    upper[i] = mid[i] + m * sd;
+    lower[i] = mid[i] - m * sd;
+  }
+  return { mid, upper, lower };
+}
+
+function stochSeries(highs, lows, closes, kPeriod, kSmooth, dPeriod) {
+  const h = nums(highs);
+  const l = nums(lows);
+  const c = nums(closes);
+  const kp = Math.max(1, Math.round(Number(kPeriod) || 14));
+  const ks = Math.max(1, Math.round(Number(kSmooth) || 3));
+  const dp = Math.max(1, Math.round(Number(dPeriod) || 3));
+  const raw = new Array(c.length).fill(null);
+  for (let i = kp - 1; i < c.length; i++) {
+    let hh = -Infinity;
+    let ll = Infinity;
+    for (let j = i - kp + 1; j <= i; j++) {
+      if (h[j] > hh) hh = h[j];
+      if (l[j] < ll) ll = l[j];
+    }
+    raw[i] = hh === ll ? 50 : ((c[i] - ll) / (hh - ll)) * 100;
+  }
+  const k = smaSeries(raw, ks);
+  const d = smaSeries(k, dp);
+  return { k, d };
+}
+
+/* "EMA(50)" | "ema50" | "RSI(14)" | "ATR(14)" | "MACD(12,26,9)" |
+   "BB(20,2)" | "SMA(200)" | "STOCH(14,3,3)" → {type, params} */
+function parseSpec(spec) {
+  const s = String(spec || '').trim().toUpperCase().replace(/\s+/g, '');
+  const m = /^([A-Z]+)\(?([0-9,.\s]*)\)?$/.exec(s);
+  if (!m) return null;
+  const type = m[1];
+  const params = (m[2] ? m[2].split(',').map((x) => Number(x)) : []).filter((x) => isFinite(x));
+  if (!['EMA', 'SMA', 'RSI', 'ATR', 'MACD', 'BB', 'STOCH'].includes(type)) return null;
+  return { type, params };
+}
+
+function lastN(series, n) {
+  const v = (Array.isArray(series) ? series : []).filter((x) => x != null);
+  const size = Math.max(1, Math.min(20, Number(n) || 1));
+  return v.slice(-size).map((x) => Math.round(x * 1e6) / 1e6);
+}
+
+/* Ham seriyi hesaplar; dönen değerler tam uzunlukta (warmup null). */
+function seriesFor(spec, rates) {
+  const closes = rates.map((r) => Number(r.close));
+  const highs = rates.map((r) => Number(r.high));
+  const lows = rates.map((r) => Number(r.low));
+  const p = spec.params;
+  switch (spec.type) {
+    case 'EMA':
+      return { name: 'EMA', params: [p[0] || 20], series: emaSeries(closes, p[0] || 20) };
+    case 'SMA':
+      return { name: 'SMA', params: [p[0] || 20], series: smaSeries(closes, p[0] || 20) };
+    case 'RSI':
+      return { name: 'RSI', params: [p[0] || 14], series: rsiSeries(closes, p[0] || 14) };
+    case 'ATR':
+      return { name: 'ATR', params: [p[0] || 14], series: atrSeries(highs, lows, closes, p[0] || 14) };
+    case 'MACD': {
+      const r = macdSeries(closes, p[0] || 12, p[1] || 26, p[2] || 9);
+      return { name: 'MACD', params: [p[0] || 12, p[1] || 26, p[2] || 9], series: r.macd, extra: { signal: r.signal, hist: r.hist } };
+    }
+    case 'BB': {
+      const r = bollingerSeries(closes, p[0] || 20, p[1] || 2);
+      return { name: 'BB', params: [p[0] || 20, p[1] || 2], series: r.mid, extra: { upper: r.upper, lower: r.lower } };
+    }
+    case 'STOCH': {
+      const r = stochSeries(highs, lows, closes, p[0] || 14, p[1] || 3, p[2] || 3);
+      return { name: 'STOCH', params: [p[0] || 14, p[1] || 3, p[2] || 3], series: r.k, extra: { d: r.d } };
+    }
+    default:
+      return null;
+  }
+}
+
+const DEFAULT_SPECS = ['EMA(20)', 'EMA(50)', 'RSI(14)', 'ATR(14)', 'MACD(12,26,9)'];
+
+/* rates: [{time, open, high, low, close, ...}] → ajan dostu özet.
+   Her gösterge için son 3 değer + (varsa) ek seriler. */
+function compute(rates, specs) {
+  const rows = Array.isArray(rates) ? rates : [];
+  const list = (Array.isArray(specs) && specs.length ? specs : DEFAULT_SPECS)
+    .map((s) => (typeof s === 'string' ? parseSpec(s) : s))
+    .filter(Boolean)
+    .slice(0, 12);
+  const close = rows.length ? Number(rows[rows.length - 1].close) : null;
+  const out = { bars: rows.length, close, indicators: {} };
+  for (const spec of list) {
+    const r = seriesFor(spec, rows);
+    if (!r) continue;
+    const key = r.name + '(' + r.params.join(',') + ')';
+    const entry = { last: lastN(r.series, 3) };
+    if (r.extra) {
+      entry.extra = {};
+      for (const [k, v] of Object.entries(r.extra)) entry.extra[k] = lastN(v, 3);
+    }
+    out.indicators[key] = entry;
+  }
+  const highs = rows.map((x) => Number(x.high));
+  const lows = rows.map((x) => Number(x.low));
+  if (highs.length) {
+    const window = Math.min(20, rows.length);
+    out.range20 = {
+      high: Math.max(...highs.slice(-window)),
+      low: Math.min(...lows.slice(-window)),
+    };
+  }
+  return out;
+}
+
+module.exports = {
+  parseSpec,
+  compute,
+  smaSeries,
+  emaSeries,
+  rsiSeries,
+  atrSeries,
+  macdSeries,
+  bollingerSeries,
+  stochSeries,
+  DEFAULT_SPECS,
+};

package/src/agent/finrisk.js

@@ -0,0 +1,132 @@
+'use strict';
+
+/* Beast Finance — işlem öncesi risk katmanı (saf; köprü/IO yok).
+   Lot normalizasyonu (broker min/max/step), %risk ile lot hesabı (SL mesafesi
+   veya ATR), stops_level doğrulaması, marj kalkanı ve yoğunluk (net yön)
+   kontrolü. financetools bu kararları uygular; birim testleri doğrudan çağırır. */
+
+function num(v, def) {
+  const n = Number(v);
+  return isFinite(n) ? n : def;
+}
+
+function stepFloor(v, step) {
+  const s = num(step, 0.01);
+  if (!(s > 0)) return v;
+  return Math.floor(v / s + 1e-9) * s;
+}
+
+/* info: MT5 symbol_info satırı. wanted: istenen lot. hardMax: kullanıcı limiti. */
+function normalizeVolume(info, wanted, hardMax) {
+  const vmin = num(info && info.volume_min, 0.01);
+  const vmax = num(info && info.volume_max, 100);
+  const step = num(info && info.volume_step, 0.01);
+  let v = num(wanted, 0);
+  if (!(v > 0)) return { error: 'volume gerekli (pozitif sayı)' };
+  const cap = Math.min(vmax > 0 ? vmax : Infinity, num(hardMax, 0) > 0 ? num(hardMax, 0) : Infinity);
+  let capped = false;
+  if (v > cap) {
+    v = stepFloor(cap, step);
+    capped = true;
+  }
+  v = Math.round(stepFloor(v, step) * 1e8) / 1e8;
+  if (!(v > 0) || v < vmin - 1e-9) {
+    return { error: `hacim broker minimumunun altında (min ${vmin} lot)` };
+  }
+  return { volume: v, capped };
+}
+
+/* 1 lot için SL mesafesi kaybı (hesap para birimi): tick değeri, yoksa kontrat */
+function lossPerLot(info, entry, sl) {
+  const dist = Math.abs(num(entry, 0) - num(sl, 0));
+  if (!(dist > 0)) return 0;
+  const tickSize = num(info && info.trade_tick_size, 0) || num(info && info.point, 0);
+  const tickValue = num(info && info.trade_tick_value, 0);
+  if (tickSize > 0 && tickValue > 0) return (dist / tickSize) * tickValue;
+  const contract = num(info && info.trade_contract_size, 0);
+  if (contract > 0) return dist * contract;
+  return 0;
+}
+
+/* riskAmount: hesap para birimi cinsinden kaybedilecek tutar */
+function calcRiskLot(info, entry, sl, riskAmount, hardMax) {
+  const lpl = lossPerLot(info, entry, sl);
+  if (!(lpl > 0)) return { error: 'risk hesaplanamadı (tick değeri/kontrat bilgisi yok)' };
+  const raw = num(riskAmount, 0) / lpl;
+  const norm = normalizeVolume(info, raw, hardMax);
+  if (norm.error) return { error: norm.error, raw, lossPerLot: lpl };
+  return {
+    volume: norm.volume,
+    raw: Math.round(raw * 1e4) / 1e4,
+    lossPerLot: Math.round(lpl * 100) / 100,
+    riskAmount: Math.round(raw * lpl * 100) / 100,
+    capped: !!norm.capped,
+  };
+}
+
+/* stops_level ihlali: SL/TP fiyata çok yakın mı? (broker reddini önler)
+   Yakınsa Türkçe hata metni, sorun yoksa null döner. */
+function stopsTooClose(info, price, sl, tp) {
+  const stops = num(info && info.trade_stops_level, 0);
+  if (!(stops > 0)) return null;
+  const point = num(info && info.point, 0);
+  if (!(point > 0)) return null;
+  const minDist = stops * point;
+  const p = num(price, 0);
+  const s = num(sl, 0);
+  const t = num(tp, 0);
+  if (p > 0 && s > 0 && Math.abs(p - s) < minDist - 1e-12) {
+    return `SL fiyata çok yakın — broker en az ${minDist.toFixed(point < 0.01 ? 3 : 2)} mesafe istiyor`;
+  }
+  if (p > 0 && t > 0 && Math.abs(p - t) < minDist - 1e-12) {
+    return `TP fiyata çok yakın — broker en az ${minDist.toFixed(point < 0.01 ? 3 : 2)} mesafe istiyor`;
+  }
+  return null;
+}
+
+/* Marj kalkanı: mevcut serbest marj + işlem sonrası tahmini marj seviyesi.
+   Sorun varsa hata metni, yoksa null. */
+function marginCheck(account, estMargin, minLevel) {
+  const equity = num(account && account.equity, 0);
+  const used = num(account && account.margin, 0);
+  const free = num(account && account.margin_free, 0);
+  const current = num(account && account.margin_level, 0);
+  const m = num(estMargin, 0);
+  const minL = num(minLevel, 0);
+  if (m > 0 && free > 0 && m > free) {
+    return { error: `yetersiz serbest marj (gerekli ~${m.toFixed(2)}, serbest ${free.toFixed(2)})` };
+  }
+  if (minL > 0 && current > 0 && current < minL) {
+    return { error: `marj seviyesi kalkanı: mevcut %${current.toFixed(0)} < min %${minL}` };
+  }
+  if (minL > 0 && equity > 0 && (used > 0 || m > 0)) {
+    const after = (equity / (used + m)) * 100;
+    if (after < minL) {
+      return { error: `marj seviyesi kalkanı: işlem sonrası tahmini %${after.toFixed(0)} < min %${minL}`, level: Math.round(after * 100) / 100 };
+    }
+  }
+  return null;
+}
+
+/* Yoğunluk: aynı yöne birikme + sembol başına aynı yön limiti.
+   Sorun varsa hata metni, yoksa null. 0 = ilgili kural kapalı. */
+function exposureCheck(positions, side, symbol, maxPerSymbol, maxSameSide) {
+  const list = Array.isArray(positions) ? positions : [];
+  const isBuy = String(side).toLowerCase() === 'buy';
+  const sym = String(symbol || '').toUpperCase();
+  const maxSame = num(maxSameSide, 0);
+  const maxSym = num(maxPerSymbol, 0);
+  if (maxSame > 0) {
+    const sameDir = list.filter((p) => (Number(p.type) === 0) === isBuy).length;
+    if (sameDir >= maxSame) return `aynı yönde ${sameDir} pozisyon var (max ${maxSame}) — çeşitlendir`;
+  }
+  if (maxSym > 0) {
+    const sameSym = list.filter(
+      (p) => String(p.symbol || '').toUpperCase() === sym && (Number(p.type) === 0) === isBuy
+    ).length;
+    if (sameSym >= maxSym) return `${sym} ${isBuy ? 'BUY' : 'SELL'} için ${sameSym} pozisyon var (max ${maxSym})`;
+  }
+  return null;
+}
+
+module.exports = { normalizeVolume, lossPerLot, calcRiskLot, stopsTooClose, marginCheck, exposureCheck };

package/src/agent/finstats.js

@@ -0,0 +1,229 @@
+'use strict';
+
+/* Beast Finance — muhasebe matematiği (saf; köprü/IO yok).
+   MT5 deals listesinden işlem istatistiği, equity serisinden drawdown ve
+   haftalık rapor metni üretir. main süreç bu çıktıları dosyaya/panoya taşır. */
+
+function num(v, def) {
+  const n = Number(v);
+  return isFinite(n) ? n : def;
+}
+
+function dayKey(ms) {
+  const d = new Date(Number(ms) || 0);
+  const p = (x) => String(x).padStart(2, '0');
+  return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate());
+}
+
+function isOut(entry) {
+  return entry === 1 || entry === '1' || String(entry) === '1';
+}
+
+function once(v, d) {
+  const n = Number(v);
+  return isFinite(n) ? n : d;
+}
+
+/* deals: [{position_id, entry, profit, swap, commission, symbol, time, volume}] */
+function summarizeDeals(deals, opts) {
+  const rows = Array.isArray(deals) ? deals : [];
+  const since = opts && Number.isFinite(Number(opts.sinceMs)) ? Number(opts.sinceMs) : 0;
+  const groups = new Map();
+  for (const dl of rows) {
+    const pid = String(dl.position_id != null ? dl.position_id : dl.ticket != null ? dl.ticket : '');
+    if (!pid) continue;
+    let g = groups.get(pid);
+    if (!g) {
+      g = { pid, symbol: String(dl.symbol || ''), net: 0, hasOut: false, openTime: Infinity, closeTime: 0, volume: 0 };
+      groups.set(pid, g);
+    }
+    g.net += once(dl.profit, 0) + once(dl.swap, 0) + once(dl.commission, 0);
+    const t = once(dl.time, 0) * (once(dl.time, 0) > 1e12 ? 1 : 1000);
+    if (t > 0) {
+      if (t < g.openTime) g.openTime = t;
+      if (t > g.closeTime) g.closeTime = t;
+    }
+    if (isOut(dl.entry)) g.hasOut = true;
+    if (!g.symbol && dl.symbol) g.symbol = String(dl.symbol);
+    g.volume = Math.max(g.volume, once(dl.volume, 0));
+  }
+  const closed = [...groups.values()].filter((g) => g.hasOut && (!since || g.closeTime >= since));
+  const total = closed.length;
+  let wins = 0;
+  let losses = 0;
+  let breakeven = 0;
+  let grossProfit = 0;
+  let grossLoss = 0;
+  let best = 0;
+  let worst = 0;
+  let bestSymbol = '';
+  let worstSymbol = '';
+  const bySymbol = {};
+  const byDay = {};
+  let lastTradeAt = 0;
+  for (const g of closed) {
+    const n = Math.round(g.net * 100) / 100;
+    const k = dayKey(g.closeTime);
+    byDay[k] = Math.round(((byDay[k] || 0) + n) * 100) / 100;
+    if (!bySymbol[g.symbol]) bySymbol[g.symbol] = { net: 0, trades: 0, wins: 0, losses: 0 };
+    const s = bySymbol[g.symbol];
+    s.net = Math.round((s.net + n) * 100) / 100;
+    s.trades++;
+    if (n > 0) {
+      wins++;
+      s.wins++;
+      grossProfit += n;
+      if (n > best) {
+        best = n;
+        bestSymbol = g.symbol;
+      }
+    } else if (n < 0) {
+      losses++;
+      s.losses++;
+      grossLoss += -n;
+      if (n < worst) {
+        worst = n;
+        worstSymbol = g.symbol;
+      }
+    } else {
+      breakeven++;
+    }
+    if (g.closeTime > lastTradeAt) lastTradeAt = g.closeTime;
+  }
+  const netProfit = Math.round((grossProfit - grossLoss) * 100) / 100;
+  return {
+    trades: total,
+    wins,
+    losses,
+    breakeven,
+    winRate: total ? Math.round((wins / total) * 1000) / 10 : 0,
+    netProfit,
+    grossProfit: Math.round(grossProfit * 100) / 100,
+    grossLoss: Math.round(grossLoss * 100) / 100,
+    profitFactor: grossLoss > 0 ? Math.round((grossProfit / grossLoss) * 100) / 100 : grossProfit > 0 ? null : 0,
+    avgWin: wins ? Math.round((grossProfit / wins) * 100) / 100 : 0,
+    avgLoss: losses ? Math.round((grossLoss / losses) * 100) / 100 : 0,
+    best: Math.round(best * 100) / 100,
+    bestSymbol,
+    worst: Math.round(worst * 100) / 100,
+    worstSymbol,
+    bySymbol,
+    byDay,
+    lastTradeAt: lastTradeAt || 0,
+    at: Date.now(),
+  };
+}
+
+/* points: [{at, equity}] — sırasız gelebilir; zamana göre sıralanır. */
+function maxDrawdown(points) {
+  const list = (Array.isArray(points) ? points : [])
+    .map((p) => ({ at: num(p && p.at, 0), equity: num(p && p.equity, NaN) }))
+    .filter((p) => isFinite(p.equity))
+    .sort((a, b) => a.at - b.at);
+  let peak = -Infinity;
+  let peakAt = 0;
+  let maxAbs = 0;
+  let maxPct = 0;
+  let troughAt = 0;
+  for (const p of list) {
+    if (p.equity > peak) {
+      peak = p.equity;
+      peakAt = p.at;
+    }
+    if (peak > 0) {
+      const abs = peak - p.equity;
+      const pct = (abs / peak) * 100;
+      if (abs > maxAbs) {
+        maxAbs = abs;
+        maxPct = pct;
+        troughAt = p.at;
+      }
+    }
+  }
+  return {
+    maxAbs: Math.round(maxAbs * 100) / 100,
+    maxPct: Math.round(maxPct * 100) / 100,
+    peakAt,
+    troughAt,
+    samples: list.length,
+  };
+}
+
+function money(v, cur) {
+  const n = num(v, 0);
+  const sign = n > 0 ? '+' : '';
+  return sign + n.toFixed(2) + (cur ? ' ' + cur : '');
+}
+
+/* Haftalık rapor metni (markdown). review: ajan eleştirisi (opsiyonel). */
+function buildWeeklyReport(ctx) {
+  const c = ctx || {};
+  const st = c.stats || {};
+  const cur = (c.account && c.account.currency) || '';
+  const L = [];
+  const from = dayKey(c.fromTs || Date.now() - 7 * 86400000);
+  const to = dayKey(c.toTs || Date.now());
+  L.push('# Beast Finance — Haftalık Rapor');
+  L.push('');
+  L.push('Dönem: **' + from + ' → ' + to + '**');
+  L.push('');
+  if (c.account) {
+    L.push('## Hesap');
+    L.push('- Bakiye: **' + num(c.account.balance, 0).toFixed(2) + ' ' + cur + '** · Özkaynak: ' + num(c.account.equity, 0).toFixed(2) + ' ' + cur);
+    L.push('- Kaldıraç: 1:' + num(c.account.leverage, 0) + ' · Para birimi: ' + (cur || '?'));
+    L.push('');
+  }
+  L.push('## Performans');
+  L.push('| Metrik | Değer |');
+  L.push('| --- | --- |');
+  L.push('| Kapanan işlem | ' + num(st.trades, 0) + ' |');
+  L.push('| Kazanç / Kayıp | ' + num(st.wins, 0) + ' / ' + num(st.losses, 0) + ' |');
+  L.push('| Win rate | %' + num(st.winRate, 0) + ' |');
+  L.push('| Net K/Z | ' + money(st.netProfit, cur) + ' |');
+  L.push('| Profit factor | ' + (st.profitFactor == null ? '∞' : st.profitFactor) + ' |');
+  if (c.drawdown) L.push('| Max drawdown | ' + num(c.drawdown.maxAbs, 0).toFixed(2) + ' ' + cur + ' (%' + num(c.drawdown.maxPct, 0) + ') |');
+  L.push('');
+  const days = Object.entries(st.byDay || {}).sort((a, b) => a[0].localeCompare(b[0])).slice(-7);
+  if (days.length) {
+    L.push('## Günlük K/Z');
+    for (const [d, v] of days) L.push('- ' + d + ': ' + money(v, cur));
+    L.push('');
+  }
+  const syms = Object.entries(st.bySymbol || {})
+    .map(([s, v]) => ({ symbol: s, ...v }))
+    .sort((a, b) => b.net - a.net)
+    .slice(0, 8);
+  if (syms.length) {
+    L.push('## Semboller');
+    L.push('| Sembol | İşlem | W/L | Net |');
+    L.push('| --- | --- | --- | --- |');
+    for (const s of syms) L.push('| ' + s.symbol + ' | ' + s.trades + ' | ' + s.wins + '/' + s.losses + ' | ' + money(s.net, cur) + ' |');
+    L.push('');
+  }
+  if (c.positions && c.positions.length) {
+    L.push('## Açık Pozisyonlar');
+    for (const p of c.positions.slice(0, 15)) {
+      L.push('- ' + (p.symbol || '?') + ' ' + (Number(p.type) === 0 ? 'BUY' : 'SELL') + ' ' + num(p.volume, 0) + ' lot @ ' + num(p.price_open, 0) + ' → K/Z ' + money(p.profit, cur));
+    }
+    L.push('');
+  }
+  if (Array.isArray(c.journal) && c.journal.length) {
+    L.push('## Son İşlem Günlüğü');
+    for (const j of c.journal.slice(-15)) {
+      const t = new Date(num(j.at, Date.now()));
+      const hh = String(t.getHours()).padStart(2, '0') + ':' + String(t.getMinutes()).padStart(2, '0');
+      L.push('- ' + hh + ' · ' + String(j.kind || '') + (j.symbol ? ' ' + j.symbol : '') + (j.side ? ' ' + j.side : '') + (j.volume ? ' ' + j.volume : '') + (j.reason ? ' — ' + String(j.reason).slice(0, 160) : ''));
+    }
+    L.push('');
+  }
+  if (c.review) {
+    L.push('## Ajan Değerlendirmesi');
+    L.push(String(c.review).trim());
+    L.push('');
+  }
+  L.push('---');
+  L.push('_Beast Finance tarafından otomatik üretildi · ' + new Date().toISOString() + '_');
+  return L.join('\n');
+}
+
+module.exports = { summarizeDeals, maxDrawdown, buildWeeklyReport, dayKey, money };