@timmeck/trading-brain 1.0.0

package/src/graph/weighted-graph.ts

@@ -0,0 +1,194 @@
+export const NODE_TYPES = {
+  SIGNAL: 'signal',
+  REGIME: 'regime',
+  OUTCOME: 'outcome',
+  PAIR: 'pair',
+  BOT_TYPE: 'bot_type',
+  TIME: 'time',
+  COMBO: 'combo',
+} as const;
+
+export type NodeType = typeof NODE_TYPES[keyof typeof NODE_TYPES];
+
+export interface GraphNode {
+  id: string;
+  type: string;
+  label: string;
+  activation: number;
+  totalActivations: number;
+}
+
+export interface GraphEdge {
+  source: string;
+  target: string;
+  weight: number;
+  activations: number;
+  lastActivated: number;
+}
+
+export interface ActivatedNode {
+  id: string;
+  type: string;
+  label: string;
+  activation: number;
+}
+
+export class WeightedGraph {
+  nodes: Record<string, GraphNode> = {};
+  edges: Record<string, GraphEdge> = {};
+
+  addNode(id: string, type: string, label: string): GraphNode {
+    if (!this.nodes[id]) {
+      this.nodes[id] = { id, type, label, activation: 0, totalActivations: 0 };
+    }
+    return this.nodes[id]!;
+  }
+
+  addEdge(sourceId: string, targetId: string, weight: number = 0.5): GraphEdge {
+    const edgeId = `${sourceId}->${targetId}`;
+    const reverseId = `${targetId}->${sourceId}`;
+    if (!this.edges[edgeId]) {
+      this.edges[edgeId] = { source: sourceId, target: targetId, weight, activations: 0, lastActivated: 0 };
+    }
+    if (!this.edges[reverseId]) {
+      this.edges[reverseId] = { source: targetId, target: sourceId, weight, activations: 0, lastActivated: 0 };
+    }
+    return this.edges[edgeId]!;
+  }
+
+  strengthenEdge(sourceId: string, targetId: string, amount: number = 0.1): void {
+    const edgeId = `${sourceId}->${targetId}`;
+    const reverseId = `${targetId}->${sourceId}`;
+    for (const id of [edgeId, reverseId]) {
+      const edge = this.edges[id];
+      if (edge) {
+        edge.weight = Math.min(1.0, edge.weight + (1.0 - edge.weight) * amount);
+        edge.activations++;
+        edge.lastActivated = Date.now();
+      }
+    }
+  }
+
+  weakenEdge(sourceId: string, targetId: string, factor: number = 0.8): void {
+    const edgeId = `${sourceId}->${targetId}`;
+    const reverseId = `${targetId}->${sourceId}`;
+    for (const id of [edgeId, reverseId]) {
+      const edge = this.edges[id];
+      if (edge) {
+        edge.weight *= factor;
+      }
+    }
+  }
+
+  /**
+   * Spreading Activation — BFS energy propagation through the graph.
+   * Returns activated nodes sorted by activation level descending.
+   */
+  spreadingActivation(
+    startNodeId: string,
+    initialEnergy: number = 1.0,
+    decayFactor: number = 0.6,
+    threshold: number = 0.05,
+    maxDepth: number = 4,
+  ): ActivatedNode[] {
+    // Reset activations
+    for (const node of Object.values(this.nodes)) {
+      node.activation = 0;
+    }
+
+    if (!this.nodes[startNodeId]) return [];
+
+    const queue: Array<{ nodeId: string; energy: number; depth: number }> = [
+      { nodeId: startNodeId, energy: initialEnergy, depth: 0 },
+    ];
+    const visited = new Set<string>();
+
+    while (queue.length > 0) {
+      const { nodeId, energy, depth } = queue.shift()!;
+
+      if (visited.has(nodeId) || energy < threshold || depth > maxDepth) continue;
+      visited.add(nodeId);
+
+      const node = this.nodes[nodeId];
+      if (!node) continue;
+
+      node.activation += energy;
+      node.totalActivations++;
+
+      // Find outgoing edges
+      for (const edge of Object.values(this.edges)) {
+        if (edge.source === nodeId && !visited.has(edge.target)) {
+          const propagatedEnergy = energy * edge.weight * decayFactor;
+          if (propagatedEnergy >= threshold) {
+            queue.push({ nodeId: edge.target, energy: propagatedEnergy, depth: depth + 1 });
+          }
+        }
+      }
+    }
+
+    return Object.values(this.nodes)
+      .filter(n => n.activation > 0)
+      .sort((a, b) => b.activation - a.activation)
+      .map(n => ({ id: n.id, type: n.type, label: n.label, activation: n.activation }));
+  }
+
+  getEdgesFor(nodeId: string): GraphEdge[] {
+    return Object.values(this.edges).filter(e => e.source === nodeId || e.target === nodeId);
+  }
+
+  /** Apply temporal decay to all edges */
+  decayEdges(halfLifeMs: number): void {
+    const now = Date.now();
+    for (const edge of Object.values(this.edges)) {
+      if (edge.lastActivated > 0) {
+        const age = now - edge.lastActivated;
+        if (age > halfLifeMs) {
+          const periods = age / halfLifeMs;
+          edge.weight = Math.max(0.01, edge.weight * Math.pow(0.5, periods));
+        }
+      }
+    }
+  }
+
+  /** Find shortest path between two nodes using BFS */
+  findPath(fromId: string, toId: string, maxDepth: number = 6): string[] | null {
+    if (!this.nodes[fromId] || !this.nodes[toId]) return null;
+    if (fromId === toId) return [fromId];
+
+    const queue: Array<{ nodeId: string; path: string[] }> = [{ nodeId: fromId, path: [fromId] }];
+    const visited = new Set<string>();
+
+    while (queue.length > 0) {
+      const { nodeId, path } = queue.shift()!;
+      if (visited.has(nodeId) || path.length > maxDepth) continue;
+      visited.add(nodeId);
+
+      for (const edge of Object.values(this.edges)) {
+        if (edge.source === nodeId && !visited.has(edge.target)) {
+          const newPath = [...path, edge.target];
+          if (edge.target === toId) return newPath;
+          queue.push({ nodeId: edge.target, path: newPath });
+        }
+      }
+    }
+
+    return null;
+  }
+
+  serialize(): { nodes: GraphNode[]; edges: GraphEdge[] } {
+    return {
+      nodes: Object.values(this.nodes),
+      edges: Object.values(this.edges),
+    };
+  }
+
+  deserialize(data: { nodes: GraphNode[]; edges: GraphEdge[] }): void {
+    this.nodes = {};
+    this.edges = {};
+    if (data.nodes) data.nodes.forEach(n => { this.nodes[n.id] = n; });
+    if (data.edges) data.edges.forEach(e => { this.edges[`${e.source}->${e.target}`] = e; });
+  }
+
+  getNodeCount(): number { return Object.keys(this.nodes).length; }
+  getEdgeCount(): number { return Object.keys(this.edges).length; }
+}

package/src/index.ts

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { startCommand } from './cli/commands/start.js';
+import { stopCommand } from './cli/commands/stop.js';
+import { statusCommand } from './cli/commands/status.js';
+import { queryCommand } from './cli/commands/query.js';
+import { insightsCommand } from './cli/commands/insights.js';
+import { rulesCommand } from './cli/commands/rules.js';
+import { networkCommand } from './cli/commands/network.js';
+import { exportCommand } from './cli/commands/export.js';
+import { importCommand } from './cli/commands/import.js';
+import { configCommand } from './cli/commands/config.js';
+import { doctorCommand } from './cli/commands/doctor.js';
+
+const program = new Command();
+
+program
+  .name('trading')
+  .description('Trading Brain — Adaptive Trading Intelligence & Signal Learning System')
+  .version('1.0.0');
+
+program.addCommand(startCommand());
+program.addCommand(stopCommand());
+program.addCommand(statusCommand());
+program.addCommand(queryCommand());
+program.addCommand(insightsCommand());
+program.addCommand(rulesCommand());
+program.addCommand(networkCommand());
+program.addCommand(exportCommand());
+program.addCommand(importCommand());
+program.addCommand(configCommand());
+program.addCommand(doctorCommand());
+
+// Hidden command: run MCP server (called by Claude Code)
+program
+  .command('mcp-server')
+  .description('Start MCP server (stdio transport, used by Claude Code)')
+  .action(async () => {
+    const { startMcpServer } = await import('./mcp/server.js');
+    await startMcpServer();
+  });
+
+// Hidden command: run daemon in foreground (called by start command)
+program
+  .command('daemon')
+  .description('Run daemon in foreground')
+  .option('-c, --config <path>', 'Config file path')
+  .action(async (opts) => {
+    const { TradingCore } = await import('./trading-core.js');
+    const core = new TradingCore();
+    core.start(opts.config);
+  });
+
+program.parse();

package/src/ipc/client.ts

@@ -0,0 +1,112 @@
+import net from 'node:net';
+import { randomUUID } from 'node:crypto';
+import type { IpcMessage } from '../types/ipc.types.js';
+import { encodeMessage, MessageDecoder } from './protocol.js';
+import { getPipeName } from '../utils/paths.js';
+
+interface PendingRequest {
+  resolve: (result: unknown) => void;
+  reject: (err: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+export class IpcClient {
+  private socket: net.Socket | null = null;
+  private decoder = new MessageDecoder();
+  private pending = new Map<string, PendingRequest>();
+  private onNotification?: (msg: IpcMessage) => void;
+
+  constructor(
+    private pipeName: string = getPipeName(),
+    private timeout: number = 5000,
+  ) {}
+
+  connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.socket = net.createConnection(this.pipeName, () => {
+        resolve();
+      });
+
+      this.socket.on('data', (chunk) => {
+        const messages = this.decoder.feed(chunk);
+        for (const msg of messages) {
+          this.handleMessage(msg);
+        }
+      });
+
+      this.socket.on('error', (err) => {
+        reject(err);
+        for (const [id, req] of this.pending) {
+          clearTimeout(req.timer);
+          req.reject(new Error(`Connection error: ${err.message}`));
+          this.pending.delete(id);
+        }
+      });
+
+      this.socket.on('close', () => {
+        for (const [id, req] of this.pending) {
+          clearTimeout(req.timer);
+          req.reject(new Error('Connection closed'));
+          this.pending.delete(id);
+        }
+        this.socket = null;
+      });
+    });
+  }
+
+  request(method: string, params?: unknown): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      if (!this.socket || this.socket.destroyed) {
+        return reject(new Error('Not connected'));
+      }
+
+      const id = randomUUID();
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Request timeout: ${method} (${this.timeout}ms)`));
+      }, this.timeout);
+
+      this.pending.set(id, { resolve, reject, timer });
+
+      const msg: IpcMessage = { id, type: 'request', method, params };
+      this.socket.write(encodeMessage(msg));
+    });
+  }
+
+  setNotificationHandler(handler: (msg: IpcMessage) => void): void {
+    this.onNotification = handler;
+  }
+
+  disconnect(): void {
+    for (const [id, req] of this.pending) {
+      clearTimeout(req.timer);
+      req.reject(new Error('Client disconnecting'));
+      this.pending.delete(id);
+    }
+    this.socket?.destroy();
+    this.socket = null;
+    this.decoder.reset();
+  }
+
+  get connected(): boolean {
+    return this.socket !== null && !this.socket.destroyed;
+  }
+
+  private handleMessage(msg: IpcMessage): void {
+    if (msg.type === 'response') {
+      const req = this.pending.get(msg.id);
+      if (!req) return;
+
+      clearTimeout(req.timer);
+      this.pending.delete(msg.id);
+
+      if (msg.error) {
+        req.reject(new Error(msg.error.message));
+      } else {
+        req.resolve(msg.result);
+      }
+    } else if (msg.type === 'notification') {
+      this.onNotification?.(msg);
+    }
+  }
+}

package/src/ipc/protocol.ts

@@ -0,0 +1,35 @@
+import { Buffer } from 'node:buffer';
+import type { IpcMessage } from '../types/ipc.types.js';
+
+export function encodeMessage(msg: IpcMessage): Buffer {
+  const json = JSON.stringify(msg);
+  const payload = Buffer.from(json, 'utf8');
+  const frame = Buffer.alloc(4 + payload.length);
+  frame.writeUInt32BE(payload.length, 0);
+  payload.copy(frame, 4);
+  return frame;
+}
+
+export class MessageDecoder {
+  private buffer = Buffer.alloc(0);
+
+  feed(chunk: Buffer): IpcMessage[] {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    const messages: IpcMessage[] = [];
+
+    while (this.buffer.length >= 4) {
+      const length = this.buffer.readUInt32BE(0);
+      if (this.buffer.length < 4 + length) break;
+
+      const json = this.buffer.subarray(4, 4 + length).toString('utf8');
+      this.buffer = this.buffer.subarray(4 + length);
+      messages.push(JSON.parse(json) as IpcMessage);
+    }
+
+    return messages;
+  }
+
+  reset(): void {
+    this.buffer = Buffer.alloc(0);
+  }
+}

package/src/ipc/router.ts

@@ -0,0 +1,113 @@
+import { getLogger } from '../utils/logger.js';
+import type { TradeService } from '../services/trade.service.js';
+import type { SignalService } from '../services/signal.service.js';
+import type { StrategyService } from '../services/strategy.service.js';
+import type { SynapseService } from '../services/synapse.service.js';
+import type { AnalyticsService } from '../services/analytics.service.js';
+import type { InsightService } from '../services/insight.service.js';
+import type { LearningEngine } from '../learning/learning-engine.js';
+import type { ResearchEngine } from '../research/research-engine.js';
+import type { RuleRepository } from '../db/repositories/rule.repository.js';
+import type { ChainRepository } from '../db/repositories/chain.repository.js';
+import type { CalibrationRepository } from '../db/repositories/calibration.repository.js';
+
+const logger = getLogger();
+
+export interface Services {
+  trade: TradeService;
+  signal: SignalService;
+  strategy: StrategyService;
+  synapse: SynapseService;
+  analytics: AnalyticsService;
+  insight: InsightService;
+  ruleRepo: RuleRepository;
+  chainRepo: ChainRepository;
+  calRepo: CalibrationRepository;
+  learning?: LearningEngine;
+  research?: ResearchEngine;
+}
+
+type MethodHandler = (params: unknown) => unknown;
+
+export class IpcRouter {
+  private methods: Map<string, MethodHandler>;
+
+  constructor(private services: Services) {
+    this.methods = this.buildMethodMap();
+  }
+
+  handle(method: string, params: unknown): unknown {
+    const handler = this.methods.get(method);
+    if (!handler) {
+      throw new Error(`Unknown method: ${method}`);
+    }
+
+    logger.debug(`IPC: ${method}`, { params });
+    const result = handler(params);
+    logger.debug(`IPC: ${method} → done`);
+    return result;
+  }
+
+  listMethods(): string[] {
+    return Array.from(this.methods.keys()).sort();
+  }
+
+  private buildMethodMap(): Map<string, MethodHandler> {
+    const s = this.services;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const p = (params: unknown) => params as any;
+
+    return new Map<string, MethodHandler>([
+      // ─── Trade ──────────────────────────────────────────
+      ['trade.recordOutcome', (params) => s.trade.recordOutcome(p(params))],
+      ['trade.query', (params) => s.trade.query(p(params).search ?? '', p(params).limit)],
+      ['trade.recent', (params) => s.trade.getRecent(p(params).limit)],
+      ['trade.byPair', (params) => s.trade.getByPair(p(params).pair)],
+      ['trade.count', () => s.trade.count()],
+
+      // ─── Signal ─────────────────────────────────────────
+      ['signal.weights', (params) => s.signal.getSignalWeights(p(params).signals, p(params).regime)],
+      ['signal.confidence', (params) => s.signal.getConfidence(p(params).signals, p(params).regime)],
+
+      // ─── Strategy ───────────────────────────────────────
+      ['strategy.dcaMultiplier', (params) => s.strategy.getDCAMultiplier(p(params).regime, p(params).rsi, p(params).volatility)],
+      ['strategy.gridParams', (params) => s.strategy.getGridParams(p(params).regime, p(params).volatility, p(params).pair)],
+
+      // ─── Synapse ────────────────────────────────────────
+      ['synapse.explore', (params) => s.synapse.explore(p(params).query)],
+      ['synapse.findPath', (params) => s.synapse.findPath(p(params).from, p(params).to)],
+      ['synapse.stats', () => s.synapse.getStats()],
+
+      // ─── Rules ──────────────────────────────────────────
+      ['rule.list', () => s.ruleRepo.getAll()],
+      ['rule.count', () => s.ruleRepo.count()],
+
+      // ─── Chains ─────────────────────────────────────────
+      ['chain.list', (params) => s.chainRepo.getRecent(p(params).limit ?? 20)],
+      ['chain.byPair', (params) => s.chainRepo.getByPair(p(params).pair)],
+
+      // ─── Insights ───────────────────────────────────────
+      ['insight.list', (params) => s.insight.getRecent(p(params).limit ?? 20)],
+      ['insight.byType', (params) => s.insight.getByType(p(params).type)],
+      ['insight.count', () => s.insight.count()],
+
+      // ─── Calibration ────────────────────────────────────
+      ['calibration.get', () => s.learning?.getCalibration() ?? s.calRepo.get()],
+
+      // ─── Analytics ──────────────────────────────────────
+      ['analytics.summary', () => s.analytics.getSummary()],
+
+      // ─── Learning ───────────────────────────────────────
+      ['learning.run', () => s.learning?.runManual()],
+
+      // ─── Research ───────────────────────────────────────
+      ['research.run', () => s.research?.runManual()],
+
+      // ─── Reset ──────────────────────────────────────────
+      ['reset', () => {
+        // This will be wired in TradingCore
+        return { success: true, message: 'Reset not available via IPC — use CLI' };
+      }],
+    ]);
+  }
+}

package/src/ipc/server.ts

@@ -0,0 +1,150 @@
+import net from 'node:net';
+import fs from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { getLogger } from '../utils/logger.js';
+import type { IpcMessage } from '../types/ipc.types.js';
+import { encodeMessage, MessageDecoder } from './protocol.js';
+import type { IpcRouter } from './router.js';
+
+export class IpcServer {
+  private server: net.Server | null = null;
+  private clients = new Map<string, net.Socket>();
+  private logger = getLogger();
+
+  constructor(
+    private router: IpcRouter,
+    private pipeName: string,
+  ) {}
+
+  start(): void {
+    this.createServer();
+    this.listen();
+  }
+
+  private createServer(): void {
+    this.server = net.createServer((socket) => {
+      const clientId = randomUUID();
+      this.clients.set(clientId, socket);
+      const decoder = new MessageDecoder();
+
+      this.logger.info(`IPC client connected: ${clientId}`);
+
+      socket.on('data', (chunk) => {
+        const messages = decoder.feed(chunk);
+        for (const msg of messages) {
+          this.handleMessage(clientId, msg, socket);
+        }
+      });
+
+      socket.on('close', () => {
+        this.logger.info(`IPC client disconnected: ${clientId}`);
+        this.clients.delete(clientId);
+      });
+
+      socket.on('error', (err) => {
+        this.logger.error(`IPC client ${clientId} error:`, err);
+        this.clients.delete(clientId);
+      });
+    });
+  }
+
+  private listen(retried = false): void {
+    if (!this.server) return;
+
+    this.server.on('error', (err: NodeJS.ErrnoException) => {
+      if (err.code === 'EADDRINUSE' && !retried) {
+        this.logger.warn(`IPC pipe in use, attempting to recover stale pipe: ${this.pipeName}`);
+        this.recoverStalePipe();
+      } else {
+        this.logger.error('IPC server error:', err);
+      }
+    });
+
+    this.server.listen(this.pipeName, () => {
+      this.logger.info(`IPC server listening on ${this.pipeName}`);
+    });
+  }
+
+  private recoverStalePipe(): void {
+    const probe = net.createConnection(this.pipeName);
+
+    probe.on('connect', () => {
+      probe.destroy();
+      this.logger.error('IPC pipe is held by another running daemon. Stop it first with: trading stop');
+    });
+
+    probe.on('error', () => {
+      probe.destroy();
+      this.logger.info('Stale IPC pipe detected, reclaiming...');
+
+      if (process.platform !== 'win32') {
+        try { fs.unlinkSync(this.pipeName); } catch { /* ignore */ }
+      }
+
+      this.createServer();
+      this.server!.on('error', (err) => {
+        this.logger.error('IPC server error after recovery:', err);
+      });
+      this.server!.listen(this.pipeName, () => {
+        this.logger.info(`IPC server recovered and listening on ${this.pipeName}`);
+      });
+    });
+
+    probe.setTimeout(2000, () => {
+      probe.destroy();
+      this.logger.warn('IPC pipe probe timed out, treating as stale');
+      if (process.platform !== 'win32') {
+        try { fs.unlinkSync(this.pipeName); } catch { /* ignore */ }
+      }
+      this.createServer();
+      this.server!.on('error', (err) => {
+        this.logger.error('IPC server error after timeout recovery:', err);
+      });
+      this.server!.listen(this.pipeName, () => {
+        this.logger.info(`IPC server recovered (timeout) and listening on ${this.pipeName}`);
+      });
+    });
+  }
+
+  private handleMessage(clientId: string, msg: IpcMessage, socket: net.Socket): void {
+    if (msg.type !== 'request' || !msg.method) return;
+
+    try {
+      const result = this.router.handle(msg.method, msg.params);
+      const response: IpcMessage = { id: msg.id, type: 'response', result };
+      socket.write(encodeMessage(response));
+    } catch (err) {
+      const response: IpcMessage = {
+        id: msg.id, type: 'response',
+        error: { code: -1, message: err instanceof Error ? err.message : String(err) },
+      };
+      socket.write(encodeMessage(response));
+    }
+  }
+
+  notify(clientId: string | null, notification: Omit<IpcMessage, 'id' | 'type'>): void {
+    const msg: IpcMessage = { id: randomUUID(), type: 'notification', ...notification };
+    const encoded = encodeMessage(msg);
+
+    if (clientId) {
+      const socket = this.clients.get(clientId);
+      if (socket && !socket.destroyed) socket.write(encoded);
+    } else {
+      for (const socket of this.clients.values()) {
+        if (!socket.destroyed) socket.write(encoded);
+      }
+    }
+  }
+
+  getClientCount(): number {
+    return this.clients.size;
+  }
+
+  stop(): void {
+    for (const socket of this.clients.values()) socket.destroy();
+    this.clients.clear();
+    this.server?.close();
+    this.server = null;
+    this.logger.info('IPC server stopped');
+  }
+}