@timmeck/trading-brain 1.0.0

package/dist/utils/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/utils/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAgB3C,MAAM,OAAO,aAAc,SAAQ,YAAY;IAC7C,IAAI,CAAkC,KAAQ,EAAE,IAA2B;QACzE,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACjC,CAAC;IAED,EAAE,CAAkC,KAAQ,EAAE,QAA+C;QAC3F,OAAO,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,CAAkC,KAAQ,EAAE,QAA+C;QAC7F,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACrC,CAAC;IAED,GAAG,CAAkC,KAAQ,EAAE,QAA+C;QAC5F,OAAO,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACpC,CAAC;CACF;AAED,IAAI,WAAW,GAAyB,IAAI,CAAC;AAE7C,MAAM,UAAU,WAAW;IACzB,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,WAAW,GAAG,IAAI,aAAa,EAAE,CAAC;IACpC,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC"}

package/dist/utils/hash.d.ts

@@ -0,0 +1 @@
+export declare function sha256(input: string): string;

package/dist/utils/hash.js

@@ -0,0 +1,5 @@
+import { createHash } from 'node:crypto';
+export function sha256(input) {
+    return createHash('sha256').update(input).digest('hex');
+}
+//# sourceMappingURL=hash.js.map

package/dist/utils/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../src/utils/hash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,MAAM,UAAU,MAAM,CAAC,KAAa;IAClC,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC1D,CAAC"}

package/dist/utils/logger.d.ts

@@ -0,0 +1,8 @@
+import winston from 'winston';
+export declare function createLogger(opts?: {
+    level?: string;
+    file?: string;
+    maxSize?: number;
+    maxFiles?: number;
+}): winston.Logger;
+export declare function getLogger(): winston.Logger;

package/dist/utils/logger.js

@@ -0,0 +1,39 @@
+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 = null;
+export function createLogger(opts) {
+    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 = [
+        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() {
+    if (!loggerInstance) {
+        return createLogger();
+    }
+    return loggerInstance;
+}
+//# sourceMappingURL=logger.js.map

package/dist/utils/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAC;AAC9B,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;AAEhE,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE;IAClE,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3E,OAAO,GAAG,SAAS,KAAK,KAAK,IAAI,OAAO,IAAI,OAAO,EAAE,CAAC;AACxD,CAAC,CAAC,CAAC;AAEH,IAAI,cAAc,GAA0B,IAAI,CAAC;AAEjD,MAAM,UAAU,YAAY,CAAC,IAA6E;IACxG,IAAI,cAAc;QAAE,OAAO,cAAc,CAAC;IAE1C,MAAM,KAAK,GAAG,IAAI,EAAE,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,IAAI,MAAM,CAAC;IAC9E,MAAM,OAAO,GAAG,IAAI,EAAE,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,mBAAmB,CAAC,CAAC;IAC3E,MAAM,OAAO,GAAG,IAAI,EAAE,OAAO,IAAI,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;IAClD,MAAM,QAAQ,GAAG,IAAI,EAAE,QAAQ,IAAI,CAAC,CAAC;IAErC,MAAM,UAAU,GAAwB;QACtC,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC;YAC1B,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,OAAO;YAChB,QAAQ;YACR,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE,EAAE,SAAS,CAAC;SACxC,CAAC;KACH,CAAC;IAEF,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,YAAY,EAAE,CAAC;QAC7C,UAAU,CAAC,IAAI,CACb,IAAI,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC;YAC7B,MAAM,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,EAAE,SAAS,CAAC;SACpD,CAAC,CACH,CAAC;IACJ,CAAC;IAED,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;IAC7D,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,SAAS;IACvB,IAAI,CAAC,cAAc,EAAE,CAAC;QACpB,OAAO,YAAY,EAAE,CAAC;IACxB,CAAC;IACD,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/dist/utils/paths.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizePath(filePath: string): string;
+export declare function getDataDir(): string;
+export declare function getPipeName(name?: string): string;

package/dist/utils/paths.js

@@ -0,0 +1,18 @@
+import path from 'node:path';
+import os from 'node:os';
+export function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+export function getDataDir() {
+    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 = 'trading-brain') {
+    if (process.platform === 'win32') {
+        return `\\\\.\\pipe\\${name}`;
+    }
+    return path.join(os.tmpdir(), `${name}.sock`);
+}
+//# sourceMappingURL=paths.js.map

package/dist/utils/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../src/utils/paths.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,MAAM,SAAS,CAAC;AAEzB,MAAM,UAAU,aAAa,CAAC,QAAgB;IAC5C,OAAO,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,UAAU;IACxB,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;IACrD,IAAI,MAAM;QAAE,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,OAAO,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,gBAAgB,CAAC,CAAC;AACnD,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,OAAe,eAAe;IACxD,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;QACjC,OAAO,gBAAgB,IAAI,EAAE,CAAC;IAChC,CAAC;IACD,OAAO,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,GAAG,IAAI,OAAO,CAAC,CAAC;AAChD,CAAC"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@timmeck/trading-brain",
+  "version": "1.0.0",
+  "description": "Adaptive trading intelligence system with Hebbian synapses, spreading activation, Wilson Score confidence, and adaptive calibration",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "trading": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "test": "vitest"
+  },
+  "keywords": [
+    "trading-brain",
+    "mcp",
+    "claude-code",
+    "hebbian-learning",
+    "spreading-activation",
+    "wilson-score",
+    "adaptive-calibration",
+    "signal-fingerprinting",
+    "pattern-extraction",
+    "trading-intelligence"
+  ],
+  "author": "Tim Mecklenburg",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/timmeck/trading-brain"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^11.7.0",
+    "chalk": "^5.6.2",
+    "commander": "^13.0.0",
+    "winston": "^3.17.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}

package/src/api/server.ts

@@ -0,0 +1,160 @@
+import http from 'node:http';
+import { getLogger } from '../utils/logger.js';
+import { getEventBus } from '../utils/events.js';
+import type { IpcRouter } from '../ipc/router.js';
+
+export interface ApiServerOptions {
+  port: number;
+  router: IpcRouter;
+  apiKey?: string;
+}
+
+export class ApiServer {
+  private server: http.Server | null = null;
+  private logger = getLogger();
+  private sseClients: Set<http.ServerResponse> = new Set();
+  private statsTimer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(private options: ApiServerOptions) {}
+
+  start(): void {
+    const { port, apiKey } = this.options;
+
+    this.server = http.createServer((req, res) => {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-API-Key');
+
+      if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
+
+      if (apiKey) {
+        const provided = (req.headers['x-api-key'] as string) ?? req.headers.authorization?.replace('Bearer ', '');
+        if (provided !== apiKey) {
+          this.json(res, 401, { error: 'Unauthorized' });
+          return;
+        }
+      }
+
+      this.handleRequest(req, res).catch((err) => {
+        this.logger.error('API error:', err);
+        this.json(res, 500, { error: err instanceof Error ? err.message : String(err) });
+      });
+    });
+
+    this.server.listen(port, () => {
+      this.logger.info(`REST API server started on http://localhost:${port}`);
+    });
+
+    this.setupSSE();
+  }
+
+  stop(): void {
+    if (this.statsTimer) { clearInterval(this.statsTimer); this.statsTimer = null; }
+    for (const client of this.sseClients) { try { client.end(); } catch { /* ignore */ } }
+    this.sseClients.clear();
+    this.server?.close();
+    this.server = null;
+    this.logger.info('REST API server stopped');
+  }
+
+  private async handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    const url = new URL(req.url ?? '/', 'http://localhost');
+    const pathname = url.pathname;
+    const method = req.method ?? 'GET';
+
+    if (pathname === '/api/v1/health') {
+      this.json(res, 200, { status: 'ok', timestamp: new Date().toISOString() });
+      return;
+    }
+
+    if (pathname === '/api/v1/events' && method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
+      res.write('data: {"type":"connected"}\n\n');
+      this.sseClients.add(res);
+      req.on('close', () => this.sseClients.delete(res));
+      return;
+    }
+
+    if (pathname === '/api/v1/methods' && method === 'GET') {
+      const methods = this.options.router.listMethods();
+      this.json(res, 200, { methods, rpcEndpoint: '/api/v1/rpc' });
+      return;
+    }
+
+    if (pathname === '/api/v1/rpc' && method === 'POST') {
+      const body = await this.readBody(req);
+      if (!body) { this.json(res, 400, { error: 'Empty request body' }); return; }
+
+      const parsed = JSON.parse(body);
+
+      if (Array.isArray(parsed)) {
+        const results = parsed.map((call: { method: string; params?: unknown; id?: string | number }) => {
+          try {
+            const result = this.options.router.handle(call.method, call.params ?? {});
+            return { id: call.id, result };
+          } catch (err) {
+            return { id: call.id, error: err instanceof Error ? err.message : String(err) };
+          }
+        });
+        this.json(res, 200, results);
+        return;
+      }
+
+      if (!parsed.method) { this.json(res, 400, { error: 'Missing "method" field' }); return; }
+
+      try {
+        const result = this.options.router.handle(parsed.method, parsed.params ?? {});
+        this.json(res, 200, { result });
+      } catch (err) {
+        this.json(res, 400, { error: err instanceof Error ? err.message : String(err) });
+      }
+      return;
+    }
+
+    this.json(res, 404, { error: `No route for ${method} ${pathname}` });
+  }
+
+  private json(res: http.ServerResponse, status: number, data: unknown): void {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data));
+  }
+
+  private readBody(req: http.IncomingMessage): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      req.on('data', (chunk: Buffer) => chunks.push(chunk));
+      req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+      req.on('error', reject);
+    });
+  }
+
+  private setupSSE(): void {
+    const bus = getEventBus();
+    const eventNames = [
+      'trade:recorded', 'synapse:updated', 'rule:learned',
+      'chain:detected', 'insight:created', 'calibration:updated',
+    ] as const;
+
+    for (const eventName of eventNames) {
+      bus.on(eventName, (data: unknown) => {
+        this.broadcastSSE({ type: 'event', event: eventName, data });
+      });
+    }
+
+    this.statsTimer = setInterval(() => {
+      if (this.sseClients.size > 0) {
+        try {
+          const summary = this.options.router.handle('analytics.summary', {});
+          this.broadcastSSE({ type: 'stats_update', stats: summary });
+        } catch { /* ignore */ }
+      }
+    }, 30_000);
+  }
+
+  private broadcastSSE(data: unknown): void {
+    const msg = `data: ${JSON.stringify(data)}\n\n`;
+    for (const client of this.sseClients) {
+      try { client.write(msg); } catch { this.sseClients.delete(client); }
+    }
+  }
+}

package/src/cli/colors.ts

@@ -0,0 +1,80 @@
+import chalk from 'chalk';
+
+export const c = {
+  blue: chalk.hex('#5b9cff'),
+  purple: chalk.hex('#b47aff'),
+  cyan: chalk.hex('#47e5ff'),
+  green: chalk.hex('#3dffa0'),
+  red: chalk.hex('#ff5577'),
+  orange: chalk.hex('#ffb347'),
+  dim: chalk.hex('#8b8fb0'),
+  dimmer: chalk.hex('#4a4d6e'),
+
+  label: chalk.hex('#8b8fb0'),
+  value: chalk.white.bold,
+  heading: chalk.hex('#5b9cff').bold,
+  success: chalk.hex('#3dffa0').bold,
+  error: chalk.hex('#ff5577').bold,
+  warn: chalk.hex('#ffb347').bold,
+  info: chalk.hex('#47e5ff'),
+};
+
+export const icons = {
+  brain: '🧠',
+  chart: '📊',
+  check: '✓',
+  cross: '✗',
+  arrow: '→',
+  dot: '●',
+  bar: '█',
+  barLight: '░',
+  dash: '─',
+  pipe: '│',
+  star: '★',
+  bolt: '⚡',
+  search: '🔍',
+  gear: '⚙',
+  synapse: '🔗',
+  insight: '💡',
+  warn: '⚠',
+  error: '❌',
+  ok: '✅',
+  clock: '⏱',
+  trade: '💹',
+  rule: '📋',
+  chain: '⛓',
+};
+
+export function header(title: string, icon?: string): string {
+  const prefix = icon ? `${icon}  ` : '';
+  const line = c.dimmer(icons.dash.repeat(40));
+  return `\n${line}\n${prefix}${c.heading(title)}\n${line}`;
+}
+
+export function keyValue(key: string, value: string | number, indent = 2): string {
+  const pad = ' '.repeat(indent);
+  return `${pad}${c.label(key + ':')} ${c.value(String(value))}`;
+}
+
+export function divider(width = 40): string {
+  return c.dimmer(icons.dash.repeat(width));
+}
+
+function stripAnsi(str: string): string {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+export function table(rows: string[][], colWidths?: number[]): string {
+  if (rows.length === 0) return '';
+  const widths = colWidths ?? rows[0]!.map((_, i) =>
+    Math.max(...rows.map(r => stripAnsi(r[i] ?? '').length))
+  );
+  return rows.map(row =>
+    row.map((cell, i) => {
+      const stripped = stripAnsi(cell);
+      const pad = Math.max(0, (widths[i] ?? stripped.length) - stripped.length);
+      return cell + ' '.repeat(pad);
+    }).join('  ')
+  ).join('\n');
+}

package/src/cli/commands/config.ts

@@ -0,0 +1,76 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDataDir } from '../../utils/paths.js';
+import { loadConfig } from '../../config.js';
+import { c, icons, header } from '../colors.js';
+
+export function configCommand(): Command {
+  const cmd = new Command('config').description('Manage configuration');
+
+  cmd.command('show')
+    .description('Show current configuration')
+    .action(() => {
+      console.log(header('Configuration', icons.gear));
+      const config = loadConfig();
+      console.log(JSON.stringify(config, null, 2));
+    });
+
+  cmd.command('set')
+    .description('Set a config value')
+    .argument('<key>', 'Config key (dot notation, e.g. api.port)')
+    .argument('<value>', 'Config value')
+    .action((key, value) => {
+      const configPath = path.join(getDataDir(), 'config.json');
+      let config: Record<string, unknown> = {};
+      if (fs.existsSync(configPath)) {
+        config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      }
+
+      const parts = key.split('.');
+      let obj = config;
+      for (let i = 0; i < parts.length - 1; i++) {
+        if (!obj[parts[i]!] || typeof obj[parts[i]!] !== 'object') {
+          obj[parts[i]!] = {};
+        }
+        obj = obj[parts[i]!] as Record<string, unknown>;
+      }
+
+      // Auto-convert numbers and booleans
+      let parsed: unknown = value;
+      if (value === 'true') parsed = true;
+      else if (value === 'false') parsed = false;
+      else if (!isNaN(Number(value))) parsed = Number(value);
+
+      obj[parts[parts.length - 1]!] = parsed;
+
+      fs.mkdirSync(path.dirname(configPath), { recursive: true });
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log(`${icons.ok}  ${c.success(`Set ${key} = ${value}`)}`);
+    });
+
+  cmd.command('delete')
+    .description('Delete a config key (revert to default)')
+    .argument('<key>', 'Config key to delete')
+    .action((key) => {
+      const configPath = path.join(getDataDir(), 'config.json');
+      if (!fs.existsSync(configPath)) {
+        console.log(`${c.dim('No config file found.')}`);
+        return;
+      }
+
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      const parts = key.split('.');
+      let obj = config;
+      for (let i = 0; i < parts.length - 1; i++) {
+        if (!obj[parts[i]!]) return;
+        obj = obj[parts[i]!];
+      }
+      delete obj[parts[parts.length - 1]!];
+
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log(`${icons.ok}  ${c.success(`Deleted ${key} (reverted to default)`)}`);
+    });
+
+  return cmd;
+}

package/src/cli/commands/doctor.ts

@@ -0,0 +1,62 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDataDir, getPipeName } from '../../utils/paths.js';
+import { c, icons, header } from '../colors.js';
+
+export function doctorCommand(): Command {
+  return new Command('doctor')
+    .description('Health check for Trading Brain')
+    .action(async () => {
+      console.log(header('Trading Brain Doctor', icons.gear));
+      let issues = 0;
+
+      // Check data dir
+      const dataDir = getDataDir();
+      if (fs.existsSync(dataDir)) {
+        console.log(`  ${icons.ok}  Data dir exists: ${c.dim(dataDir)}`);
+      } else {
+        console.log(`  ${icons.warn}  Data dir missing: ${c.dim(dataDir)}`);
+        issues++;
+      }
+
+      // Check DB
+      const dbPath = path.join(dataDir, 'trading-brain.db');
+      if (fs.existsSync(dbPath)) {
+        const stat = fs.statSync(dbPath);
+        console.log(`  ${icons.ok}  Database exists: ${c.dim(`${(stat.size / 1024).toFixed(0)} KB`)}`);
+      } else {
+        console.log(`  ${icons.warn}  Database not yet created ${c.dim('(will be created on first start)')}`);
+      }
+
+      // Check PID
+      const pidPath = path.join(dataDir, 'trading-brain.pid');
+      if (fs.existsSync(pidPath)) {
+        const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
+        try {
+          process.kill(pid, 0);
+          console.log(`  ${icons.ok}  Daemon running ${c.dim(`(PID ${pid})`)}`);
+        } catch {
+          console.log(`  ${icons.warn}  Stale PID file ${c.dim(`(PID ${pid} not running)`)}`);
+          issues++;
+        }
+      } else {
+        console.log(`  ${icons.warn}  Daemon not running`);
+      }
+
+      // Check pipe
+      const pipeName = getPipeName();
+      console.log(`  ${c.dim('IPC:')} ${pipeName}`);
+
+      // Check ports
+      console.log(`  ${c.dim('REST API:')} http://localhost:7779`);
+      console.log(`  ${c.dim('MCP HTTP:')} http://localhost:7780`);
+
+      console.log();
+      if (issues === 0) {
+        console.log(`  ${icons.ok}  ${c.success('All checks passed!')}`);
+      } else {
+        console.log(`  ${icons.warn}  ${c.warn(`${issues} issue(s) found`)}`);
+      }
+    });
+}

package/src/cli/commands/export.ts

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons } from '../colors.js';
+
+export function exportCommand(): Command {
+  return new Command('export')
+    .description('Export all brain data as JSON')
+    .option('-o, --output <file>', 'Output file path', 'trading-brain-export.json')
+    .action(async (opts) => {
+      await withIpc(async (client) => {
+        const summary = await client.request('analytics.summary', {});
+        const rules = await client.request('rule.list', {});
+        const chains = await client.request('chain.list', { limit: 100 });
+        const insights = await client.request('insight.list', { limit: 100 });
+        const network = await client.request('synapse.stats', {});
+        const calibration = await client.request('calibration.get', {});
+
+        const data = { summary, rules, chains, insights, network, calibration, exportedAt: new Date().toISOString() };
+        fs.writeFileSync(opts.output, JSON.stringify(data, null, 2));
+        console.log(`${icons.ok}  ${c.success(`Exported to ${opts.output}`)}`);
+      });
+    });
+}

package/src/cli/commands/import.ts

@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons } from '../colors.js';
+
+export function importCommand(): Command {
+  return new Command('import')
+    .description('Import trades from JSON file')
+    .argument('<file>', 'JSON file to import')
+    .action(async (file) => {
+      if (!fs.existsSync(file)) {
+        console.error(`${icons.error}  ${c.error(`File not found: ${file}`)}`);
+        process.exit(1);
+      }
+
+      const raw = fs.readFileSync(file, 'utf-8');
+      const data = JSON.parse(raw);
+
+      if (!Array.isArray(data)) {
+        console.error(`${icons.error}  ${c.error('Expected JSON array of trade objects.')}`);
+        process.exit(1);
+      }
+
+      await withIpc(async (client) => {
+        let imported = 0;
+        for (const trade of data) {
+          try {
+            await client.request('trade.recordOutcome', {
+              signals: trade.signals ?? {},
+              regime: trade.regime,
+              profitPct: trade.profitPct ?? trade.profit_pct ?? 0,
+              win: trade.win ?? false,
+              botType: trade.botType ?? trade.bot_type ?? 'unknown',
+              pair: trade.pair ?? 'unknown',
+            });
+            imported++;
+          } catch (err) {
+            console.error(`${icons.warn}  ${c.warn(`Failed to import trade: ${err}`)}`);
+          }
+        }
+        console.log(`${icons.ok}  ${c.success(`Imported ${imported}/${data.length} trades`)}`);
+      });
+    });
+}

package/src/cli/commands/insights.ts

@@ -0,0 +1,30 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons, header } from '../colors.js';
+
+export function insightsCommand(): Command {
+  return new Command('insights')
+    .description('Show research insights')
+    .option('-t, --type <type>', 'Filter by type (trend, gap, synergy, performance, regime_shift)')
+    .option('-l, --limit <n>', 'Max results', '10')
+    .action(async (opts) => {
+      console.log(header('Research Insights', icons.insight));
+
+      await withIpc(async (client) => {
+        const method = opts.type ? 'insight.byType' : 'insight.list';
+        const params = opts.type ? { type: opts.type } : { limit: Number(opts.limit) };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const results: any = await client.request(method, params);
+        if (!results?.length) {
+          console.log(`  ${c.dim('No insights found.')}`);
+          return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        for (const ins of results) {
+          const sev = ins.severity === 'high' ? c.red(`[${ins.severity}]`) : ins.severity === 'medium' ? c.orange(`[${ins.severity}]`) : c.dim(`[${ins.severity}]`);
+          console.log(`  ${sev} ${c.cyan(ins.type)} — ${c.value(ins.title)}`);
+          console.log(`    ${c.dim(ins.description)}`);
+        }
+      });
+    });
+}

package/src/cli/commands/network.ts

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons, header, keyValue } from '../colors.js';
+
+export function networkCommand(): Command {
+  return new Command('network')
+    .description('Show synapse network overview')
+    .option('-n, --node <id>', 'Explore from specific node')
+    .action(async (opts) => {
+      console.log(header('Synapse Network', icons.synapse));
+
+      await withIpc(async (client) => {
+        if (opts.node) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const activated: any = await client.request('synapse.explore', { query: opts.node });
+          if (!activated?.length) {
+            console.log(`  ${c.dim(`No node found matching "${opts.node}"`)}`);
+            return;
+          }
+          console.log(`  ${c.info('Spreading Activation from:')} ${c.value(opts.node)}\n`);
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          for (const node of activated.slice(0, 20)) {
+            const bar = c.cyan('█'.repeat(Math.round(node.activation * 20)));
+            console.log(`  ${bar} ${c.dim(node.type)} ${c.value(node.label)} ${c.dim(`(${node.activation.toFixed(3)})`)}`);
+          }
+        } else {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const stats: any = await client.request('synapse.stats', {});
+          console.log(keyValue('Synapses', stats.totalSynapses));
+          console.log(keyValue('Avg Weight', stats.avgWeight?.toFixed(3) ?? '0'));
+          console.log(keyValue('Graph Nodes', stats.graphNodes));
+          console.log(keyValue('Graph Edges', stats.graphEdges));
+          if (stats.strongest?.length > 0) {
+            console.log(`\n  ${c.cyan.bold('Strongest Synapses:')}`);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            for (const s of stats.strongest) {
+              console.log(`    ${c.green(s.weight.toFixed(3))} ${c.dim(`(${s.activations}x)`)} ${c.value(s.id)}`);
+            }
+          }
+        }
+      });
+    });
+}