@timmeck/trading-brain 1.0.0

package/src/db/repositories/calibration.repository.ts

@@ -0,0 +1,86 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { CalibrationConfig } from '../../types/config.types.js';
+
+export interface CalibrationRecord {
+  id: string;
+  learning_rate: number;
+  weaken_penalty: number;
+  decay_half_life_days: number;
+  pattern_extraction_interval: number;
+  pattern_min_samples: number;
+  pattern_wilson_threshold: number;
+  wilson_z: number;
+  spreading_activation_decay: number;
+  spreading_activation_threshold: number;
+  min_activations_for_weight: number;
+  min_outcomes_for_weights: number;
+  last_calibration: string;
+  updated_at: string;
+}
+
+export class CalibrationRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      upsert: db.prepare(`
+        INSERT INTO calibration (id, learning_rate, weaken_penalty, decay_half_life_days,
+          pattern_extraction_interval, pattern_min_samples, pattern_wilson_threshold,
+          wilson_z, spreading_activation_decay, spreading_activation_threshold,
+          min_activations_for_weight, min_outcomes_for_weights, last_calibration, updated_at)
+        VALUES ('main', @learning_rate, @weaken_penalty, @decay_half_life_days,
+          @pattern_extraction_interval, @pattern_min_samples, @pattern_wilson_threshold,
+          @wilson_z, @spreading_activation_decay, @spreading_activation_threshold,
+          @min_activations_for_weight, @min_outcomes_for_weights, datetime('now'), datetime('now'))
+        ON CONFLICT(id) DO UPDATE SET
+          learning_rate = @learning_rate, weaken_penalty = @weaken_penalty,
+          decay_half_life_days = @decay_half_life_days,
+          pattern_extraction_interval = @pattern_extraction_interval,
+          pattern_min_samples = @pattern_min_samples,
+          pattern_wilson_threshold = @pattern_wilson_threshold,
+          wilson_z = @wilson_z,
+          spreading_activation_decay = @spreading_activation_decay,
+          spreading_activation_threshold = @spreading_activation_threshold,
+          min_activations_for_weight = @min_activations_for_weight,
+          min_outcomes_for_weights = @min_outcomes_for_weights,
+          last_calibration = datetime('now'), updated_at = datetime('now')
+      `),
+      get: db.prepare('SELECT * FROM calibration WHERE id = "main"'),
+    };
+  }
+
+  save(cal: CalibrationConfig): void {
+    this.stmts['upsert']!.run({
+      learning_rate: cal.learningRate,
+      weaken_penalty: cal.weakenPenalty,
+      decay_half_life_days: cal.decayHalfLifeDays,
+      pattern_extraction_interval: cal.patternExtractionInterval,
+      pattern_min_samples: cal.patternMinSamples,
+      pattern_wilson_threshold: cal.patternWilsonThreshold,
+      wilson_z: cal.wilsonZ,
+      spreading_activation_decay: cal.spreadingActivationDecay,
+      spreading_activation_threshold: cal.spreadingActivationThreshold,
+      min_activations_for_weight: cal.minActivationsForWeight,
+      min_outcomes_for_weights: cal.minOutcomesForWeights,
+    });
+  }
+
+  get(): CalibrationConfig | null {
+    const row = this.stmts['get']!.get() as CalibrationRecord | undefined;
+    if (!row) return null;
+    return {
+      learningRate: row.learning_rate,
+      weakenPenalty: row.weaken_penalty,
+      decayHalfLifeDays: row.decay_half_life_days,
+      patternExtractionInterval: row.pattern_extraction_interval,
+      patternMinSamples: row.pattern_min_samples,
+      patternWilsonThreshold: row.pattern_wilson_threshold,
+      wilsonZ: row.wilson_z,
+      spreadingActivationDecay: row.spreading_activation_decay,
+      spreadingActivationThreshold: row.spreading_activation_threshold,
+      minActivationsForWeight: row.min_activations_for_weight,
+      minOutcomesForWeights: row.min_outcomes_for_weights,
+    };
+  }
+}

package/src/db/repositories/chain.repository.ts

@@ -0,0 +1,70 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface ChainRecord {
+  id: number;
+  pair: string;
+  type: string;
+  length: number;
+  fingerprints_json: string;
+  total_profit: number;
+  created_at: string;
+}
+
+export class ChainRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO chains (pair, type, length, fingerprints_json, total_profit)
+        VALUES (@pair, @type, @length, @fingerprints_json, @total_profit)
+      `),
+      getAll: db.prepare('SELECT * FROM chains ORDER BY created_at DESC'),
+      getRecent: db.prepare('SELECT * FROM chains ORDER BY created_at DESC LIMIT ?'),
+      getByPair: db.prepare('SELECT * FROM chains WHERE pair = ? ORDER BY created_at DESC'),
+      getByType: db.prepare('SELECT * FROM chains WHERE type = ? ORDER BY created_at DESC'),
+      count: db.prepare('SELECT COUNT(*) as count FROM chains'),
+      deleteOldest: db.prepare('DELETE FROM chains WHERE id IN (SELECT id FROM chains ORDER BY created_at ASC LIMIT ?)'),
+    };
+  }
+
+  create(data: { pair: string; type: string; length: number; fingerprints: string[]; total_profit: number }): number {
+    const result = this.stmts['create']!.run({
+      pair: data.pair,
+      type: data.type,
+      length: data.length,
+      fingerprints_json: JSON.stringify(data.fingerprints),
+      total_profit: data.total_profit,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getAll(): ChainRecord[] {
+    return this.stmts['getAll']!.all() as ChainRecord[];
+  }
+
+  getRecent(limit: number = 10): ChainRecord[] {
+    return this.stmts['getRecent']!.all(limit) as ChainRecord[];
+  }
+
+  getByPair(pair: string): ChainRecord[] {
+    return this.stmts['getByPair']!.all(pair) as ChainRecord[];
+  }
+
+  getByType(type: string): ChainRecord[] {
+    return this.stmts['getByType']!.all(type) as ChainRecord[];
+  }
+
+  count(): number {
+    const row = this.stmts['count']!.get() as { count: number };
+    return row.count;
+  }
+
+  pruneOldest(keepCount: number): void {
+    const total = this.count();
+    if (total > keepCount) {
+      this.stmts['deleteOldest']!.run(total - keepCount);
+    }
+  }
+}

package/src/db/repositories/graph.repository.ts

@@ -0,0 +1,103 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface GraphNodeRecord {
+  id: string;
+  type: string;
+  label: string;
+  activation: number;
+  total_activations: number;
+}
+
+export interface GraphEdgeRecord {
+  id: string;
+  source: string;
+  target: string;
+  weight: number;
+  activations: number;
+  last_activated: string;
+}
+
+export class GraphRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      upsertNode: db.prepare(`
+        INSERT INTO graph_nodes (id, type, label, activation, total_activations)
+        VALUES (@id, @type, @label, @activation, @total_activations)
+        ON CONFLICT(id) DO UPDATE SET
+          activation = @activation, total_activations = @total_activations
+      `),
+      upsertEdge: db.prepare(`
+        INSERT INTO graph_edges (id, source, target, weight, activations, last_activated)
+        VALUES (@id, @source, @target, @weight, @activations, @last_activated)
+        ON CONFLICT(id) DO UPDATE SET
+          weight = @weight, activations = @activations, last_activated = @last_activated
+      `),
+      getAllNodes: db.prepare('SELECT * FROM graph_nodes'),
+      getAllEdges: db.prepare('SELECT * FROM graph_edges'),
+      getNode: db.prepare('SELECT * FROM graph_nodes WHERE id = ?'),
+      getEdge: db.prepare('SELECT * FROM graph_edges WHERE id = ?'),
+      getEdgesFrom: db.prepare('SELECT * FROM graph_edges WHERE source = ?'),
+      getEdgesTo: db.prepare('SELECT * FROM graph_edges WHERE target = ?'),
+      getEdgesFor: db.prepare('SELECT * FROM graph_edges WHERE source = ? OR target = ?'),
+      nodeCount: db.prepare('SELECT COUNT(*) as count FROM graph_nodes'),
+      edgeCount: db.prepare('SELECT COUNT(*) as count FROM graph_edges'),
+      updateEdgeWeight: db.prepare('UPDATE graph_edges SET weight = ?, activations = activations + 1, last_activated = datetime("now") WHERE id = ?'),
+      deleteAllNodes: db.prepare('DELETE FROM graph_nodes'),
+      deleteAllEdges: db.prepare('DELETE FROM graph_edges'),
+    };
+  }
+
+  upsertNode(node: GraphNodeRecord): void {
+    this.stmts['upsertNode']!.run(node);
+  }
+
+  upsertEdge(edge: GraphEdgeRecord): void {
+    this.stmts['upsertEdge']!.run(edge);
+  }
+
+  getAllNodes(): GraphNodeRecord[] {
+    return this.stmts['getAllNodes']!.all() as GraphNodeRecord[];
+  }
+
+  getAllEdges(): GraphEdgeRecord[] {
+    return this.stmts['getAllEdges']!.all() as GraphEdgeRecord[];
+  }
+
+  getNode(id: string): GraphNodeRecord | undefined {
+    return this.stmts['getNode']!.get(id) as GraphNodeRecord | undefined;
+  }
+
+  getEdge(id: string): GraphEdgeRecord | undefined {
+    return this.stmts['getEdge']!.get(id) as GraphEdgeRecord | undefined;
+  }
+
+  getEdgesFrom(nodeId: string): GraphEdgeRecord[] {
+    return this.stmts['getEdgesFrom']!.all(nodeId) as GraphEdgeRecord[];
+  }
+
+  getEdgesFor(nodeId: string): GraphEdgeRecord[] {
+    return this.stmts['getEdgesFor']!.all(nodeId, nodeId) as GraphEdgeRecord[];
+  }
+
+  nodeCount(): number {
+    const row = this.stmts['nodeCount']!.get() as { count: number };
+    return row.count;
+  }
+
+  edgeCount(): number {
+    const row = this.stmts['edgeCount']!.get() as { count: number };
+    return row.count;
+  }
+
+  updateEdgeWeight(id: string, weight: number): void {
+    this.stmts['updateEdgeWeight']!.run(weight, id);
+  }
+
+  clearAll(): void {
+    this.stmts['deleteAllEdges']!.run();
+    this.stmts['deleteAllNodes']!.run();
+  }
+}

package/src/db/repositories/insight.repository.ts

@@ -0,0 +1,80 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface InsightRecord {
+  id: number;
+  type: string;
+  severity: string;
+  title: string;
+  description: string;
+  data_json: string | null;
+  created_at: string;
+}
+
+export class InsightRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO insights (type, severity, title, description, data_json)
+        VALUES (@type, @severity, @title, @description, @data_json)
+      `),
+      getAll: db.prepare('SELECT * FROM insights ORDER BY created_at DESC'),
+      getRecent: db.prepare('SELECT * FROM insights ORDER BY created_at DESC LIMIT ?'),
+      getByType: db.prepare('SELECT * FROM insights WHERE type = ? ORDER BY created_at DESC'),
+      getBySeverity: db.prepare('SELECT * FROM insights WHERE severity = ? ORDER BY created_at DESC'),
+      count: db.prepare('SELECT COUNT(*) as count FROM insights'),
+      search: db.prepare('SELECT insights.* FROM insights_fts JOIN insights ON insights_fts.rowid = insights.id WHERE insights_fts MATCH ? LIMIT ?'),
+      deleteOldest: db.prepare('DELETE FROM insights WHERE id IN (SELECT id FROM insights ORDER BY created_at ASC LIMIT ?)'),
+      deleteAll: db.prepare('DELETE FROM insights'),
+    };
+  }
+
+  create(data: { type: string; severity: string; title: string; description: string; data?: unknown }): number {
+    const result = this.stmts['create']!.run({
+      type: data.type,
+      severity: data.severity,
+      title: data.title,
+      description: data.description,
+      data_json: data.data ? JSON.stringify(data.data) : null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getAll(): InsightRecord[] {
+    return this.stmts['getAll']!.all() as InsightRecord[];
+  }
+
+  getRecent(limit: number = 10): InsightRecord[] {
+    return this.stmts['getRecent']!.all(limit) as InsightRecord[];
+  }
+
+  getByType(type: string): InsightRecord[] {
+    return this.stmts['getByType']!.all(type) as InsightRecord[];
+  }
+
+  getBySeverity(severity: string): InsightRecord[] {
+    return this.stmts['getBySeverity']!.all(severity) as InsightRecord[];
+  }
+
+  count(): number {
+    const row = this.stmts['count']!.get() as { count: number };
+    return row.count;
+  }
+
+  search(query: string, limit: number = 20): InsightRecord[] {
+    return this.stmts['search']!.all(query, limit) as InsightRecord[];
+  }
+
+  pruneOldest(keepCount: number): void {
+    const total = this.count();
+    if (total > keepCount) {
+      this.stmts['deleteOldest']!.run(total - keepCount);
+    }
+  }
+
+  deleteAll(): void {
+    this.stmts['deleteAll']!.run();
+  }
+}

package/src/db/repositories/rule.repository.ts

@@ -0,0 +1,67 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface RuleRecord {
+  id: number;
+  pattern: string;
+  confidence: number;
+  sample_count: number;
+  win_rate: number;
+  avg_profit: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export class RuleRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO rules (pattern, confidence, sample_count, win_rate, avg_profit)
+        VALUES (@pattern, @confidence, @sample_count, @win_rate, @avg_profit)
+      `),
+      getAll: db.prepare('SELECT * FROM rules ORDER BY confidence DESC'),
+      getById: db.prepare('SELECT * FROM rules WHERE id = ?'),
+      count: db.prepare('SELECT COUNT(*) as count FROM rules'),
+      deleteAll: db.prepare('DELETE FROM rules'),
+      deleteById: db.prepare('DELETE FROM rules WHERE id = ?'),
+    };
+  }
+
+  create(data: { pattern: string; confidence: number; sample_count: number; win_rate: number; avg_profit: number }): number {
+    const result = this.stmts['create']!.run(data);
+    return result.lastInsertRowid as number;
+  }
+
+  getAll(): RuleRecord[] {
+    return this.stmts['getAll']!.all() as RuleRecord[];
+  }
+
+  getById(id: number): RuleRecord | undefined {
+    return this.stmts['getById']!.get(id) as RuleRecord | undefined;
+  }
+
+  count(): number {
+    const row = this.stmts['count']!.get() as { count: number };
+    return row.count;
+  }
+
+  deleteAll(): void {
+    this.stmts['deleteAll']!.run();
+  }
+
+  delete(id: number): void {
+    this.stmts['deleteById']!.run(id);
+  }
+
+  replaceAll(rules: { pattern: string; confidence: number; sample_count: number; win_rate: number; avg_profit: number }[]): void {
+    const tx = this.db.transaction(() => {
+      this.stmts['deleteAll']!.run();
+      for (const rule of rules) {
+        this.stmts['create']!.run(rule);
+      }
+    });
+    tx();
+  }
+}

package/src/db/repositories/signal.repository.ts

@@ -0,0 +1,48 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface SignalComboRecord {
+  id: number;
+  fingerprint: string;
+  signals_json: string;
+  regime: string | null;
+  created_at: string;
+}
+
+export class SignalRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO signal_combos (fingerprint, signals_json, regime)
+        VALUES (@fingerprint, @signals_json, @regime)
+      `),
+      getByFingerprint: db.prepare('SELECT * FROM signal_combos WHERE fingerprint = ? ORDER BY created_at DESC'),
+      getAll: db.prepare('SELECT * FROM signal_combos ORDER BY created_at DESC'),
+      count: db.prepare('SELECT COUNT(*) as count FROM signal_combos'),
+    };
+  }
+
+  create(fingerprint: string, signalsJson: string, regime?: string): number {
+    const result = this.stmts['create']!.run({
+      fingerprint,
+      signals_json: signalsJson,
+      regime: regime ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getByFingerprint(fingerprint: string): SignalComboRecord[] {
+    return this.stmts['getByFingerprint']!.all(fingerprint) as SignalComboRecord[];
+  }
+
+  getAll(): SignalComboRecord[] {
+    return this.stmts['getAll']!.all() as SignalComboRecord[];
+  }
+
+  count(): number {
+    const row = this.stmts['count']!.get() as { count: number };
+    return row.count;
+  }
+}

package/src/db/repositories/synapse.repository.ts

@@ -0,0 +1,71 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface SynapseRecord {
+  id: string;
+  fingerprint: string;
+  weight: number;
+  wins: number;
+  losses: number;
+  activations: number;
+  total_profit: number;
+  last_activated: string;
+  created_at: string;
+}
+
+export class SynapseRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      upsert: db.prepare(`
+        INSERT INTO synapses (id, fingerprint, weight, wins, losses, activations, total_profit, last_activated)
+        VALUES (@id, @fingerprint, @weight, @wins, @losses, @activations, @total_profit, @last_activated)
+        ON CONFLICT(id) DO UPDATE SET
+          weight = @weight, wins = @wins, losses = @losses,
+          activations = @activations, total_profit = @total_profit,
+          last_activated = @last_activated
+      `),
+      getById: db.prepare('SELECT * FROM synapses WHERE id = ?'),
+      getAll: db.prepare('SELECT * FROM synapses ORDER BY weight DESC'),
+      count: db.prepare('SELECT COUNT(*) as count FROM synapses'),
+      updateWeight: db.prepare('UPDATE synapses SET weight = ?, last_activated = datetime("now") WHERE id = ?'),
+      deleteById: db.prepare('DELETE FROM synapses WHERE id = ?'),
+      getByMinWeight: db.prepare('SELECT * FROM synapses WHERE weight >= ? ORDER BY weight DESC'),
+      getStrongest: db.prepare('SELECT * FROM synapses ORDER BY weight DESC LIMIT ?'),
+    };
+  }
+
+  upsert(synapse: Omit<SynapseRecord, 'created_at'>): void {
+    this.stmts['upsert']!.run(synapse);
+  }
+
+  getById(id: string): SynapseRecord | undefined {
+    return this.stmts['getById']!.get(id) as SynapseRecord | undefined;
+  }
+
+  getAll(): SynapseRecord[] {
+    return this.stmts['getAll']!.all() as SynapseRecord[];
+  }
+
+  count(): number {
+    const row = this.stmts['count']!.get() as { count: number };
+    return row.count;
+  }
+
+  updateWeight(id: string, weight: number): void {
+    this.stmts['updateWeight']!.run(weight, id);
+  }
+
+  delete(id: string): void {
+    this.stmts['deleteById']!.run(id);
+  }
+
+  getByMinWeight(minWeight: number): SynapseRecord[] {
+    return this.stmts['getByMinWeight']!.all(minWeight) as SynapseRecord[];
+  }
+
+  getStrongest(limit: number = 20): SynapseRecord[] {
+    return this.stmts['getStrongest']!.all(limit) as SynapseRecord[];
+  }
+}

package/src/db/repositories/trade.repository.ts

@@ -0,0 +1,97 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface TradeRecord {
+  id: number;
+  fingerprint: string;
+  pair: string;
+  bot_type: string;
+  regime: string | null;
+  profit_pct: number;
+  win: number;
+  signals_json: string | null;
+  created_at: string;
+}
+
+export interface CreateTradeData {
+  fingerprint: string;
+  pair: string;
+  bot_type: string;
+  regime?: string;
+  profit_pct: number;
+  win: boolean;
+  signals_json?: string;
+}
+
+export class TradeRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO trades (fingerprint, pair, bot_type, regime, profit_pct, win, signals_json)
+        VALUES (@fingerprint, @pair, @bot_type, @regime, @profit_pct, @win, @signals_json)
+      `),
+      getById: db.prepare('SELECT * FROM trades WHERE id = ?'),
+      count: db.prepare('SELECT COUNT(*) as count FROM trades'),
+      getAll: db.prepare('SELECT * FROM trades ORDER BY created_at DESC'),
+      getRecent: db.prepare('SELECT * FROM trades ORDER BY created_at DESC LIMIT ?'),
+      getByPair: db.prepare('SELECT * FROM trades WHERE pair = ? ORDER BY created_at DESC'),
+      getByFingerprint: db.prepare('SELECT * FROM trades WHERE fingerprint = ? ORDER BY created_at DESC'),
+      getByBotType: db.prepare('SELECT * FROM trades WHERE bot_type = ? ORDER BY created_at DESC'),
+      getSince: db.prepare('SELECT * FROM trades WHERE created_at > ? ORDER BY created_at DESC'),
+      search: db.prepare(`SELECT * FROM trades WHERE fingerprint LIKE ? OR pair LIKE ? OR bot_type LIKE ? ORDER BY created_at DESC LIMIT ?`),
+    };
+  }
+
+  create(data: CreateTradeData): number {
+    const result = this.stmts['create']!.run({
+      fingerprint: data.fingerprint,
+      pair: data.pair,
+      bot_type: data.bot_type,
+      regime: data.regime ?? null,
+      profit_pct: data.profit_pct,
+      win: data.win ? 1 : 0,
+      signals_json: data.signals_json ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): TradeRecord | undefined {
+    return this.stmts['getById']!.get(id) as TradeRecord | undefined;
+  }
+
+  count(): number {
+    const row = this.stmts['count']!.get() as { count: number };
+    return row.count;
+  }
+
+  getAll(): TradeRecord[] {
+    return this.stmts['getAll']!.all() as TradeRecord[];
+  }
+
+  getRecent(limit: number = 10): TradeRecord[] {
+    return this.stmts['getRecent']!.all(limit) as TradeRecord[];
+  }
+
+  getByPair(pair: string): TradeRecord[] {
+    return this.stmts['getByPair']!.all(pair) as TradeRecord[];
+  }
+
+  getByFingerprint(fingerprint: string): TradeRecord[] {
+    return this.stmts['getByFingerprint']!.all(fingerprint) as TradeRecord[];
+  }
+
+  getByBotType(botType: string): TradeRecord[] {
+    return this.stmts['getByBotType']!.all(botType) as TradeRecord[];
+  }
+
+  getSince(dateStr: string): TradeRecord[] {
+    return this.stmts['getSince']!.all(dateStr) as TradeRecord[];
+  }
+
+  search(query: string, limit: number = 50): TradeRecord[] {
+    const like = `%${query}%`;
+    return this.stmts['search']!.all(like, like, like, limit) as TradeRecord[];
+  }
+}