@timmeck/trading-brain 1.0.0

package/src/types/config.types.ts

@@ -0,0 +1,60 @@
+export interface TradingBrainConfig {
+  dataDir: string;
+  dbPath: string;
+
+  ipc: {
+    pipeName: string;
+    timeout: number;
+  };
+
+  api: {
+    port: number;
+    enabled: boolean;
+    apiKey?: string;
+  };
+
+  mcpHttp: {
+    port: number;
+    enabled: boolean;
+  };
+
+  calibration: CalibrationConfig;
+  learning: LearningConfig;
+  research: ResearchConfig;
+
+  log: {
+    level: string;
+    file: string;
+    maxSize: number;
+    maxFiles: number;
+  };
+}
+
+export interface CalibrationConfig {
+  learningRate: number;
+  weakenPenalty: number;
+  decayHalfLifeDays: number;
+  patternExtractionInterval: number;
+  patternMinSamples: number;
+  patternWilsonThreshold: number;
+  wilsonZ: number;
+  spreadingActivationDecay: number;
+  spreadingActivationThreshold: number;
+  minActivationsForWeight: number;
+  minOutcomesForWeights: number;
+}
+
+export interface LearningConfig {
+  intervalMs: number;
+  fingerprintSimilarityThreshold: number;
+  chainMinLength: number;
+  maxChains: number;
+}
+
+export interface ResearchConfig {
+  intervalMs: number;
+  initialDelayMs: number;
+  trendWindowDays: number;
+  minTrades: number;
+  maxInsights: number;
+}

package/src/types/ipc.types.ts

@@ -0,0 +1,8 @@
+export interface IpcMessage {
+  id: string;
+  type: 'request' | 'response' | 'notification';
+  method?: string;
+  params?: unknown;
+  result?: unknown;
+  error?: { code: number; message: string };
+}

package/src/utils/events.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from 'node:events';
+
+export interface TradingBrainEvents {
+  'trade:recorded': { tradeId: number; fingerprint: string; win: boolean };
+  'synapse:updated': { synapseId: string; weight: number };
+  'rule:learned': { ruleId: number; pattern: string; confidence: number };
+  'chain:detected': { pair: string; type: string; length: number };
+  'insight:created': { insightId: number; type: string };
+  'calibration:updated': { outcomeCount: number; learningRate: number };
+  'decay:applied': { synapseCount: number; edgeCount: number };
+  'patterns:extracted': { ruleCount: number };
+  'research:completed': { insightCount: number };
+}
+
+export type TradingBrainEventName = keyof TradingBrainEvents;
+
+export class TypedEventBus extends EventEmitter {
+  emit<K extends TradingBrainEventName>(event: K, data: TradingBrainEvents[K]): boolean {
+    return super.emit(event, data);
+  }
+
+  on<K extends TradingBrainEventName>(event: K, listener: (data: TradingBrainEvents[K]) => void): this {
+    return super.on(event, listener);
+  }
+
+  once<K extends TradingBrainEventName>(event: K, listener: (data: TradingBrainEvents[K]) => void): this {
+    return super.once(event, listener);
+  }
+
+  off<K extends TradingBrainEventName>(event: K, listener: (data: TradingBrainEvents[K]) => void): this {
+    return super.off(event, listener);
+  }
+}
+
+let busInstance: TypedEventBus | null = null;
+
+export function getEventBus(): TypedEventBus {
+  if (!busInstance) {
+    busInstance = new TypedEventBus();
+  }
+  return busInstance;
+}

package/src/utils/hash.ts

@@ -0,0 +1,5 @@
+import { createHash } from 'node:crypto';
+
+export function sha256(input: string): string {
+  return createHash('sha256').update(input).digest('hex');
+}

package/src/utils/logger.ts

@@ -0,0 +1,48 @@
+import winston from 'winston';
+import path from 'node:path';
+import { getDataDir } from './paths.js';
+
+const { combine, timestamp, printf, colorize } = winston.format;
+
+const logFormat = printf(({ level, message, timestamp, ...meta }) => {
+  const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
+  return `${timestamp} [${level}]${metaStr} ${message}`;
+});
+
+let loggerInstance: winston.Logger | null = null;
+
+export function createLogger(opts?: { level?: string; file?: string; maxSize?: number; maxFiles?: number }): winston.Logger {
+  if (loggerInstance) return loggerInstance;
+
+  const level = opts?.level ?? process.env['TRADING_BRAIN_LOG_LEVEL'] ?? 'info';
+  const logFile = opts?.file ?? path.join(getDataDir(), 'trading-brain.log');
+  const maxSize = opts?.maxSize ?? 10 * 1024 * 1024;
+  const maxFiles = opts?.maxFiles ?? 3;
+
+  const transports: winston.transport[] = [
+    new winston.transports.File({
+      filename: logFile,
+      maxsize: maxSize,
+      maxFiles,
+      format: combine(timestamp(), logFormat),
+    }),
+  ];
+
+  if (process.env['NODE_ENV'] !== 'production') {
+    transports.push(
+      new winston.transports.Console({
+        format: combine(colorize(), timestamp(), logFormat),
+      })
+    );
+  }
+
+  loggerInstance = winston.createLogger({ level, transports });
+  return loggerInstance;
+}
+
+export function getLogger(): winston.Logger {
+  if (!loggerInstance) {
+    return createLogger();
+  }
+  return loggerInstance;
+}

package/src/utils/paths.ts

@@ -0,0 +1,19 @@
+import path from 'node:path';
+import os from 'node:os';
+
+export function normalizePath(filePath: string): string {
+  return filePath.replace(/\\/g, '/');
+}
+
+export function getDataDir(): string {
+  const envDir = process.env['TRADING_BRAIN_DATA_DIR'];
+  if (envDir) return path.resolve(envDir);
+  return path.join(os.homedir(), '.trading-brain');
+}
+
+export function getPipeName(name: string = 'trading-brain'): string {
+  if (process.platform === 'win32') {
+    return `\\\\.\\pipe\\${name}`;
+  }
+  return path.join(os.tmpdir(), `${name}.sock`);
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}