@timmeck/trading-brain 1.0.0

package/src/research/research-engine.ts

@@ -0,0 +1,223 @@
+import type { TradeRepository, TradeRecord } from '../db/repositories/trade.repository.js';
+import type { InsightRepository } from '../db/repositories/insight.repository.js';
+import type { ResearchConfig } from '../types/config.types.js';
+import { getLogger } from '../utils/logger.js';
+import { getEventBus } from '../utils/events.js';
+
+interface NewInsight {
+  type: string;
+  severity: string;
+  title: string;
+  description: string;
+  data?: unknown;
+}
+
+function mode(arr: string[]): string | null {
+  if (arr.length === 0) return null;
+  const freq: Record<string, number> = {};
+  arr.forEach(v => { freq[v] = (freq[v] || 0) + 1; });
+  let maxCount = 0, maxVal: string | null = null;
+  for (const [val, count] of Object.entries(freq)) {
+    if (count > maxCount) { maxCount = count; maxVal = val; }
+  }
+  return maxVal;
+}
+
+export class ResearchEngine {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private logger = getLogger();
+
+  constructor(
+    private config: ResearchConfig,
+    private tradeRepo: TradeRepository,
+    private insightRepo: InsightRepository,
+  ) {}
+
+  start(): void {
+    // Initial delay before first run
+    setTimeout(() => {
+      this.runCycle();
+      this.timer = setInterval(() => this.runCycle(), this.config.intervalMs);
+    }, this.config.initialDelayMs);
+    this.logger.info(`Research engine started (interval: ${this.config.intervalMs}ms)`);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  runCycle(): void {
+    const bus = getEventBus();
+    const trades = this.tradeRepo.getAll();
+    if (trades.length < this.config.minTrades) return;
+
+    const now = Date.now();
+    const insights: NewInsight[] = [];
+
+    this.detectTrends(trades, now, insights);
+    this.detectGaps(trades, insights);
+    this.detectSynergies(trades, insights);
+    this.detectPerformance(trades, insights);
+    this.detectRegimeShifts(trades, now, insights);
+
+    // Save insights
+    for (const ins of insights) {
+      const id = this.insightRepo.create(ins);
+      bus.emit('insight:created', { insightId: id, type: ins.type });
+    }
+
+    // Prune old insights
+    this.insightRepo.pruneOldest(this.config.maxInsights);
+
+    if (insights.length > 0) {
+      this.logger.info(`Research: ${insights.length} new insights`);
+    }
+  }
+
+  private detectTrends(trades: TradeRecord[], now: number, insights: NewInsight[]): void {
+    const recentCutoff = new Date(now - this.config.trendWindowDays * 86400000).toISOString();
+    const olderCutoff = new Date(now - 30 * 86400000).toISOString();
+
+    const recent = trades.filter(o => o.created_at > recentCutoff);
+    const older = trades.filter(o => o.created_at > olderCutoff && o.created_at <= recentCutoff);
+
+    if (recent.length >= 5 && older.length >= 5) {
+      const recentWinRate = recent.filter(o => o.win === 1).length / recent.length;
+      const olderWinRate = older.filter(o => o.win === 1).length / older.length;
+      const delta = recentWinRate - olderWinRate;
+
+      if (Math.abs(delta) > 0.1) {
+        insights.push({
+          type: 'trend',
+          severity: Math.abs(delta) > 0.2 ? 'high' : 'medium',
+          title: delta > 0 ? 'Win-Rate steigt' : 'Win-Rate sinkt',
+          description: `Win-Rate ${delta > 0 ? 'gestiegen' : 'gesunken'}: ${(olderWinRate * 100).toFixed(0)}% → ${(recentWinRate * 100).toFixed(0)}% (letzte ${this.config.trendWindowDays} Tage vs. vorher)`,
+          data: { recentWinRate, olderWinRate, delta },
+        });
+      }
+    }
+  }
+
+  private detectGaps(trades: TradeRecord[], insights: NewInsight[]): void {
+    const regimeGroups: Record<string, TradeRecord[]> = {};
+    trades.forEach(o => {
+      const parts = o.fingerprint.split('|');
+      const regime = parts[4] || 'unknown';
+      if (!regimeGroups[regime]) regimeGroups[regime] = [];
+      regimeGroups[regime]!.push(o);
+    });
+
+    for (const [regime, group] of Object.entries(regimeGroups)) {
+      if (group.length < 5 && group.length > 0) {
+        insights.push({
+          type: 'gap',
+          severity: 'low',
+          title: `Datenlücke: ${regime}`,
+          description: `Nur ${group.length} Trades im Regime "${regime}" — Brain braucht mehr Daten für zuverlässige Gewichtung`,
+          data: { regime, count: group.length },
+        });
+      }
+    }
+  }
+
+  private detectSynergies(trades: TradeRecord[], insights: NewInsight[]): void {
+    const botTypeGroups: Record<string, TradeRecord[]> = {};
+    trades.forEach(o => {
+      if (!botTypeGroups[o.bot_type]) botTypeGroups[o.bot_type] = [];
+      botTypeGroups[o.bot_type]!.push(o);
+    });
+
+    const botTypes = Object.keys(botTypeGroups);
+    if (botTypes.length < 2) return;
+
+    for (let i = 0; i < botTypes.length; i++) {
+      for (let j = i + 1; j < botTypes.length; j++) {
+        const a = botTypeGroups[botTypes[i]!]!;
+        const b = botTypeGroups[botTypes[j]!]!;
+        const aFps = new Set(a.map(o => o.fingerprint));
+        const bFps = new Set(b.map(o => o.fingerprint));
+        let shared = 0;
+        aFps.forEach(fp => { if (bFps.has(fp)) shared++; });
+
+        if (shared > 0) {
+          insights.push({
+            type: 'synergy',
+            severity: shared > 3 ? 'high' : 'medium',
+            title: `Synergie: ${botTypes[i]} ↔ ${botTypes[j]}`,
+            description: `${shared} gemeinsame Signal-Muster — Erfahrungen von ${botTypes[i]} helfen ${botTypes[j]}`,
+            data: { botA: botTypes[i], botB: botTypes[j], sharedPatterns: shared },
+          });
+        }
+      }
+    }
+  }
+
+  private detectPerformance(trades: TradeRecord[], insights: NewInsight[]): void {
+    const fpGroups: Record<string, TradeRecord[]> = {};
+    trades.forEach(o => {
+      if (!fpGroups[o.fingerprint]) fpGroups[o.fingerprint] = [];
+      fpGroups[o.fingerprint]!.push(o);
+    });
+
+    let bestFp: string | null = null, worstFp: string | null = null;
+    let bestWR = 0, worstWR = 1;
+
+    for (const [fp, group] of Object.entries(fpGroups)) {
+      if (group.length < 5) continue;
+      const wr = group.filter(o => o.win === 1).length / group.length;
+      if (wr > bestWR) { bestWR = wr; bestFp = fp; }
+      if (wr < worstWR) { worstWR = wr; worstFp = fp; }
+    }
+
+    if (bestFp && bestWR > 0.6) {
+      insights.push({
+        type: 'performance',
+        severity: 'high',
+        title: 'Stärkstes Signal-Muster',
+        description: `"${bestFp.split('|').join(' + ')}" hat ${(bestWR * 100).toFixed(0)}% Win-Rate (n=${fpGroups[bestFp]!.length})`,
+        data: { fingerprint: bestFp, winRate: bestWR, count: fpGroups[bestFp]!.length },
+      });
+    }
+    if (worstFp && worstWR < 0.35) {
+      insights.push({
+        type: 'performance',
+        severity: 'high',
+        title: 'Schwächstes Signal-Muster',
+        description: `"${worstFp.split('|').join(' + ')}" hat nur ${(worstWR * 100).toFixed(0)}% Win-Rate (n=${fpGroups[worstFp]!.length}) — Brain reduziert Gewichtung`,
+        data: { fingerprint: worstFp, winRate: worstWR, count: fpGroups[worstFp]!.length },
+      });
+    }
+  }
+
+  private detectRegimeShifts(trades: TradeRecord[], now: number, insights: NewInsight[]): void {
+    const recentCutoff = new Date(now - this.config.trendWindowDays * 86400000).toISOString();
+    const recent = trades.filter(o => o.created_at > recentCutoff);
+    const older = trades.filter(o => o.created_at <= recentCutoff).slice(-10);
+
+    if (recent.length < 3) return;
+
+    const recentRegimes = recent.map(o => o.fingerprint.split('|')[4] || 'unknown');
+    const prevRegimes = older.map(o => o.fingerprint.split('|')[4] || 'unknown');
+    const recentMode = mode(recentRegimes);
+    const prevMode = mode(prevRegimes);
+
+    if (recentMode && prevMode && recentMode !== prevMode) {
+      insights.push({
+        type: 'regime_shift',
+        severity: 'high',
+        title: 'Regime-Wechsel erkannt',
+        description: `Marktregime hat sich verschoben: "${prevMode}" → "${recentMode}"`,
+        data: { from: prevMode, to: recentMode },
+      });
+    }
+  }
+
+  /** Manual trigger */
+  runManual(): number {
+    this.runCycle();
+    return this.insightRepo.count();
+  }
+}

package/src/services/analytics.service.ts

@@ -0,0 +1,68 @@
+import type { TradeRepository } from '../db/repositories/trade.repository.js';
+import type { RuleRepository } from '../db/repositories/rule.repository.js';
+import type { ChainRepository } from '../db/repositories/chain.repository.js';
+import type { InsightRepository } from '../db/repositories/insight.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { WeightedGraph } from '../graph/weighted-graph.js';
+
+export class AnalyticsService {
+  constructor(
+    private tradeRepo: TradeRepository,
+    private ruleRepo: RuleRepository,
+    private chainRepo: ChainRepository,
+    private insightRepo: InsightRepository,
+    private synapseManager: SynapseManager,
+    private graph: WeightedGraph,
+  ) {}
+
+  getSummary(): Record<string, unknown> {
+    const tradeCount = this.tradeRepo.count();
+    const recentTrades = this.tradeRepo.getRecent(10);
+    const rules = this.ruleRepo.getAll();
+    const chains = this.chainRepo.getRecent(5);
+    const insights = this.insightRepo.getRecent(5);
+
+    const wins = recentTrades.filter(t => t.win === 1).length;
+    const recentWinRate = recentTrades.length > 0 ? wins / recentTrades.length : 0;
+
+    const topRule = rules.length > 0 ? {
+      pattern: rules[0]!.pattern,
+      winRate: Math.round(rules[0]!.win_rate * 100),
+      confidence: Math.round(rules[0]!.confidence * 100),
+      sampleCount: rules[0]!.sample_count,
+    } : null;
+
+    return {
+      trades: {
+        total: tradeCount,
+        recentWinRate: Math.round(recentWinRate * 100),
+      },
+      rules: {
+        total: rules.length,
+        topRule,
+      },
+      chains: {
+        total: this.chainRepo.count(),
+        recent: chains.map(c => ({
+          pair: c.pair,
+          type: c.type,
+          length: c.length,
+        })),
+      },
+      insights: {
+        total: this.insightRepo.count(),
+        recent: insights.map(i => ({
+          type: i.type,
+          severity: i.severity,
+          title: i.title,
+        })),
+      },
+      network: {
+        synapses: this.synapseManager.count(),
+        avgWeight: Number(this.synapseManager.getAvgWeight().toFixed(3)),
+        graphNodes: this.graph.getNodeCount(),
+        graphEdges: this.graph.getEdgeCount(),
+      },
+    };
+  }
+}

package/src/services/insight.service.ts

@@ -0,0 +1,29 @@
+import type { InsightRepository, InsightRecord } from '../db/repositories/insight.repository.js';
+
+export class InsightService {
+  constructor(private insightRepo: InsightRepository) {}
+
+  getAll(): InsightRecord[] {
+    return this.insightRepo.getAll();
+  }
+
+  getRecent(limit: number = 10): InsightRecord[] {
+    return this.insightRepo.getRecent(limit);
+  }
+
+  getByType(type: string): InsightRecord[] {
+    return this.insightRepo.getByType(type);
+  }
+
+  getBySeverity(severity: string): InsightRecord[] {
+    return this.insightRepo.getBySeverity(severity);
+  }
+
+  search(query: string, limit: number = 20): InsightRecord[] {
+    return this.insightRepo.search(query, limit);
+  }
+
+  count(): number {
+    return this.insightRepo.count();
+  }
+}

package/src/services/signal.service.ts

@@ -0,0 +1,109 @@
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { WeightedGraph } from '../graph/weighted-graph.js';
+import type { CalibrationConfig } from '../types/config.types.js';
+import { fingerprint, classifyVolatility, type SignalInput } from '../signals/fingerprint.js';
+import { wilsonScore } from '../signals/wilson-score.js';
+import { NODE_TYPES } from '../graph/weighted-graph.js';
+
+const DEFAULT_WEIGHTS: Record<string, number> = {
+  rsi_oversold: 30,
+  rsi_overbought: 30,
+  rsi7_oversold: 15,
+  rsi7_overbought: 15,
+  macd_bullish: 20,
+  macd_bearish: 20,
+  trend_up: 15,
+  trend_down: 15,
+  mean_reversion_buy: 10,
+  mean_reversion_sell: 10,
+  combo_bonus: 0,
+};
+
+export class SignalService {
+  constructor(
+    private synapseManager: SynapseManager,
+    private graph: WeightedGraph,
+    private cal: CalibrationConfig,
+    private tradeCount: () => number,
+  ) {}
+
+  updateCalibration(cal: CalibrationConfig): void {
+    this.cal = cal;
+  }
+
+  /**
+   * Get brain-weighted signal strengths based on learned experience.
+   * Ported from tradingBrain.js getSignalWeights().
+   */
+  getSignalWeights(signals: SignalInput, regime?: string): Record<string, number> {
+    const weights = { ...DEFAULT_WEIGHTS };
+    if (this.tradeCount() < this.cal.minOutcomesForWeights) return weights;
+
+    const fp = fingerprint({ ...signals, regime });
+    const synapse = this.synapseManager.getByFingerprint(fp);
+
+    // Direct synapse match (fast path)
+    if (synapse && synapse.activations >= this.cal.minActivationsForWeight) {
+      const factor = synapse.weight / 0.5;
+      for (const key of Object.keys(DEFAULT_WEIGHTS)) {
+        if (key !== 'combo_bonus') {
+          weights[key] = Math.round(DEFAULT_WEIGHTS[key]! * factor);
+        }
+      }
+    }
+
+    // Spreading activation for combo bonus
+    const comboNodeId = `combo_${fp}`;
+    if (this.graph.nodes[comboNodeId]) {
+      const activated = this.graph.spreadingActivation(
+        comboNodeId, 1.0,
+        this.cal.spreadingActivationDecay,
+        this.cal.spreadingActivationThreshold,
+        3,
+      );
+
+      let winEnergy = 0;
+      let lossEnergy = 0;
+      for (const node of activated) {
+        if (node.id === 'outcome_win') winEnergy = node.activation;
+        if (node.id === 'outcome_loss') lossEnergy = node.activation;
+      }
+
+      const netEnergy = winEnergy - lossEnergy;
+      if (Math.abs(netEnergy) > 0.05) {
+        const spreadBonus = Math.round(netEnergy * 30);
+        weights['combo_bonus'] = Math.max(-20, Math.min(30, spreadBonus));
+      }
+
+      // Similar combo nodes boost
+      let similarBoost = 0;
+      for (const node of activated) {
+        if (node.type === NODE_TYPES.COMBO && node.id !== comboNodeId && node.activation > 0.1) {
+          const simSyn = this.synapseManager.getByFingerprint(node.label);
+          if (simSyn && simSyn.weight > 0.6 && simSyn.activations >= 3) {
+            similarBoost += Math.round((simSyn.weight - 0.5) * 10 * node.activation);
+          }
+        }
+      }
+      weights['combo_bonus'] = Math.max(-20, Math.min(30, (weights['combo_bonus'] ?? 0) + similarBoost));
+    }
+
+    return weights;
+  }
+
+  /**
+   * Get Wilson Score confidence for signal pattern.
+   * Ported from tradingBrain.js getConfidence().
+   */
+  getConfidence(signals: SignalInput, regime?: string): number {
+    if (this.tradeCount() < this.cal.minOutcomesForWeights) return 0.5;
+
+    const fp = fingerprint({ ...signals, regime });
+    const synapse = this.synapseManager.getByFingerprint(fp);
+
+    if (!synapse || synapse.activations < this.cal.minActivationsForWeight) return 0.5;
+
+    const total = synapse.wins + synapse.losses;
+    return wilsonScore(synapse.wins, total, this.cal.wilsonZ);
+  }
+}

package/src/services/strategy.service.ts

@@ -0,0 +1,130 @@
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { WeightedGraph } from '../graph/weighted-graph.js';
+import type { CalibrationConfig } from '../types/config.types.js';
+import { fingerprint, fingerprintSimilarity, classifyVolatility, type SignalInput } from '../signals/fingerprint.js';
+
+export interface DCAMultiplierResult {
+  multiplier: number;
+  reason: string;
+}
+
+export interface GridParamsResult {
+  spacingMultiplier: number;
+  reason: string;
+}
+
+export class StrategyService {
+  constructor(
+    private synapseManager: SynapseManager,
+    private graph: WeightedGraph,
+    private cal: CalibrationConfig,
+    private tradeCount: () => number,
+  ) {}
+
+  updateCalibration(cal: CalibrationConfig): void {
+    this.cal = cal;
+  }
+
+  /**
+   * Brain-recommended DCA multiplier based on regime success.
+   * Ported from tradingBrain.js getDCAMultiplier().
+   */
+  getDCAMultiplier(regime: string, rsi: number, volatility: number): DCAMultiplierResult {
+    const result: DCAMultiplierResult = { multiplier: 1.0, reason: 'Standard' };
+    if (this.tradeCount() < 10) return result;
+
+    const signals: SignalInput = { rsi14: rsi, macd: 0, trendScore: 0, volatility };
+    const fp = fingerprint({ ...signals, regime });
+
+    // Try spreading activation from regime node
+    const regimeNodeId = `regime_${regime}`;
+    let bestWeight = 0.5;
+    let bestActivations = 0;
+
+    if (this.graph.nodes[regimeNodeId]) {
+      const activated = this.graph.spreadingActivation(regimeNodeId, 1.0, 0.5, 0.05, 3);
+      const winNode = activated.find(n => n.id === 'outcome_win');
+      const lossNode = activated.find(n => n.id === 'outcome_loss');
+      if (winNode || lossNode) {
+        const winE = winNode?.activation || 0;
+        const lossE = lossNode?.activation || 0;
+        const total = winE + lossE;
+        if (total > 0) {
+          bestWeight = winE / total;
+          bestActivations = 10;
+        }
+      }
+    }
+
+    // Fallback: fingerprint similarity scan
+    if (bestActivations < 5) {
+      for (const syn of this.synapseManager.getAll()) {
+        const sim = fingerprintSimilarity(fp, syn.fingerprint);
+        if (sim >= 0.6 && syn.activations > bestActivations) {
+          bestWeight = syn.weight;
+          bestActivations = syn.activations;
+        }
+      }
+    }
+
+    if (bestActivations >= 5) {
+      result.multiplier = Math.max(0.3, Math.min(2.5, bestWeight * 2));
+      const winRate = bestWeight > 0.5 ? 'hohe' : 'niedrige';
+      result.reason = `Brain: ${winRate} Recovery-Rate (n=${bestActivations})`;
+    }
+
+    return result;
+  }
+
+  /**
+   * Brain-recommended grid spacing based on volatility history.
+   * Ported from tradingBrain.js getGridParams().
+   */
+  getGridParams(regime: string, volatility: number, pair: string): GridParamsResult {
+    const result: GridParamsResult = { spacingMultiplier: 1.0, reason: 'Standard' };
+    if (this.tradeCount() < 10) return result;
+
+    const volClass = classifyVolatility(volatility);
+    const volNodeId = `sig_vol_${volClass}`;
+
+    if (this.graph.nodes[volNodeId]) {
+      const activated = this.graph.spreadingActivation(volNodeId, 1.0, 0.5, 0.05, 3);
+      const winNode = activated.find(n => n.id === 'outcome_win');
+      const lossNode = activated.find(n => n.id === 'outcome_loss');
+      if (winNode || lossNode) {
+        const winE = winNode?.activation || 0;
+        const lossE = lossNode?.activation || 0;
+        const ratio = (winE - lossE) / Math.max(winE + lossE, 0.01);
+        if (ratio < -0.2) {
+          result.spacingMultiplier = 1.3 + Math.abs(ratio) * 0.5;
+          result.reason = `Brain: ${volClass} Vol historisch schwach → breitere Grids`;
+        } else if (ratio > 0.2) {
+          result.spacingMultiplier = 0.7 + (1 - ratio) * 0.3;
+          result.reason = `Brain: ${volClass} Vol historisch stark → engere Grids`;
+        }
+        return result;
+      }
+    }
+
+    // Fallback: synapse scan
+    const signals: SignalInput = { rsi14: 50, macd: 0, trendScore: 0, volatility };
+    const fp = fingerprint({ ...signals, regime });
+    let totalWeight = 0, count = 0;
+    for (const syn of this.synapseManager.getAll()) {
+      const sim = fingerprintSimilarity(fp, syn.fingerprint);
+      if (sim >= 0.6 && syn.activations >= 3) { totalWeight += syn.weight; count++; }
+    }
+    if (count >= 2) {
+      const avgWeight = totalWeight / count;
+      if (avgWeight < 0.4) {
+        result.spacingMultiplier = 1.3 + (0.4 - avgWeight);
+        result.reason = `Brain: historisch schwach → breitere Grids`;
+      } else if (avgWeight > 0.6) {
+        result.spacingMultiplier = 0.7 + (1.0 - avgWeight) * 0.5;
+        result.reason = `Brain: historisch stark → engere Grids`;
+      }
+    }
+
+    return result;
+  }
+}

package/src/services/synapse.service.ts

@@ -0,0 +1,58 @@
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { WeightedGraph, ActivatedNode } from '../graph/weighted-graph.js';
+
+export class SynapseService {
+  constructor(
+    private synapseManager: SynapseManager,
+    private graph: WeightedGraph,
+  ) {}
+
+  explore(query: string): ActivatedNode[] {
+    // Find matching node (exact or fuzzy)
+    let startNode: string | null = null;
+    for (const node of Object.values(this.graph.nodes)) {
+      if (node.id === query || node.label === query) {
+        startNode = node.id;
+        break;
+      }
+    }
+
+    if (!startNode) {
+      const queryLower = query.toLowerCase();
+      for (const node of Object.values(this.graph.nodes)) {
+        if (node.label.toLowerCase().includes(queryLower) || node.id.toLowerCase().includes(queryLower)) {
+          startNode = node.id;
+          break;
+        }
+      }
+    }
+
+    if (!startNode) return [];
+    return this.graph.spreadingActivation(startNode, 1.0, 0.6, 0.05, 4);
+  }
+
+  findPath(fromId: string, toId: string): string[] | null {
+    return this.graph.findPath(fromId, toId);
+  }
+
+  getStats(): {
+    totalSynapses: number;
+    avgWeight: number;
+    graphNodes: number;
+    graphEdges: number;
+    strongest: Array<{ id: string; weight: number; activations: number }>;
+  } {
+    const strongest = this.synapseManager.getStrongest(5).map(s => ({
+      id: s.id,
+      weight: s.weight,
+      activations: s.activations,
+    }));
+    return {
+      totalSynapses: this.synapseManager.count(),
+      avgWeight: this.synapseManager.getAvgWeight(),
+      graphNodes: this.graph.getNodeCount(),
+      graphEdges: this.graph.getEdgeCount(),
+      strongest,
+    };
+  }
+}