@timmeck/brain-core 1.1.0 → 1.2.0

package/src/cli/colors.ts

@@ -1,105 +0,0 @@
-import chalk from 'chalk';
-
-// Shared brand color palette — identical across all brains
-export const c = {
-  // Primary palette
-  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'),
-
-  // Semantic
-  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'),
-};
-
-// Shared base icons — each brain extends with domain-specific icons
-export const baseIcons = {
-  check: '\u2713',
-  cross: '\u2717',
-  arrow: '\u2192',
-  dot: '\u25CF',
-  circle: '\u25CB',
-  bar: '\u2588',
-  barLight: '\u2591',
-  dash: '\u2500',
-  pipe: '\u2502',
-  corner: '\u2514',
-  tee: '\u251C',
-  star: '\u2605',
-  bolt: '\u26A1',
-  gear: '\u2699',
-  chart: '\uD83D\uDCCA',
-  synapse: '\uD83D\uDD17',
-  insight: '\uD83D\uDCA1',
-  warn: '\u26A0',
-  error: '\u274C',
-  ok: '\u2705',
-  clock: '\u23F1',
-};
-
-export function header(title: string, icon?: string): string {
-  const prefix = icon ? `${icon}  ` : '';
-  const line = c.dimmer(baseIcons.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 statusBadge(status: string): string {
-  switch (status.toLowerCase()) {
-    case 'resolved':
-    case 'active':
-    case 'running':
-      return c.green(`[${status.toUpperCase()}]`);
-    case 'open':
-    case 'unresolved':
-      return c.red(`[${status.toUpperCase()}]`);
-    case 'warning':
-      return c.warn(`[${status.toUpperCase()}]`);
-    default:
-      return c.dim(`[${status.toUpperCase()}]`);
-  }
-}
-
-export function progressBar(current: number, total: number, width = 20): string {
-  const pct = Math.min(1, current / Math.max(1, total));
-  const filled = Math.round(pct * width);
-  const empty = width - filled;
-  return c.cyan(baseIcons.bar.repeat(filled)) + c.dimmer(baseIcons.barLight.repeat(empty));
-}
-
-export function divider(width = 40): string {
-  return c.dimmer(baseIcons.dash.repeat(width));
-}
-
-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');
-}
-
-export function stripAnsi(str: string): string {
-  // eslint-disable-next-line no-control-regex
-  return str.replace(/\x1b\[[0-9;]*m/g, '');
-}

package/src/cross-brain/client.ts

@@ -1,94 +0,0 @@
-import { IpcClient } from '../ipc/client.js';
-import { getPipeName } from '../utils/paths.js';
-
-export interface BrainPeer {
-  name: string;
-  pipeName: string;
-}
-
-const DEFAULT_PEERS: BrainPeer[] = [
-  { name: 'brain', pipeName: getPipeName('brain') },
-  { name: 'trading-brain', pipeName: getPipeName('trading-brain') },
-  { name: 'marketing-brain', pipeName: getPipeName('marketing-brain') },
-];
-
-export class CrossBrainClient {
-  private peers: BrainPeer[];
-
-  constructor(
-    private selfName: string,
-    peers?: BrainPeer[],
-  ) {
-    this.peers = (peers ?? DEFAULT_PEERS).filter(p => p.name !== selfName);
-  }
-
-  /**
-   * Query a specific peer brain by name.
-   * Returns null if the peer is not available.
-   */
-  async query(peerName: string, method: string, params?: unknown): Promise<unknown | null> {
-    const peer = this.peers.find(p => p.name === peerName);
-    if (!peer) return null;
-
-    const client = new IpcClient(peer.pipeName, 3000);
-    try {
-      await client.connect();
-      const result = await client.request(method, params);
-      return result;
-    } catch {
-      return null;
-    } finally {
-      client.disconnect();
-    }
-  }
-
-  /**
-   * Broadcast a query to all available peer brains.
-   * Returns results from all peers that responded.
-   */
-  async broadcast(method: string, params?: unknown): Promise<{ name: string; result: unknown }[]> {
-    const results: { name: string; result: unknown }[] = [];
-
-    const promises = this.peers.map(async (peer) => {
-      const client = new IpcClient(peer.pipeName, 3000);
-      try {
-        await client.connect();
-        const result = await client.request(method, params);
-        results.push({ name: peer.name, result });
-      } catch {
-        // Peer not available — skip
-      } finally {
-        client.disconnect();
-      }
-    });
-
-    await Promise.all(promises);
-    return results;
-  }
-
-  /**
-   * Check which peer brains are currently running.
-   */
-  async getAvailablePeers(): Promise<string[]> {
-    const available: string[] = [];
-
-    const checks = this.peers.map(async (peer) => {
-      const client = new IpcClient(peer.pipeName, 1000);
-      try {
-        await client.connect();
-        available.push(peer.name);
-      } catch {
-        // Not available
-      } finally {
-        client.disconnect();
-      }
-    });
-
-    await Promise.all(checks);
-    return available;
-  }
-
-  getPeerNames(): string[] {
-    return this.peers.map(p => p.name);
-  }
-}

package/src/db/connection.ts

@@ -1,22 +0,0 @@
-import Database from 'better-sqlite3';
-import fs from 'node:fs';
-import path from 'node:path';
-import { getLogger } from '../utils/logger.js';
-
-export function createConnection(dbPath: string): Database.Database {
-  const logger = getLogger();
-  const dir = path.dirname(dbPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-
-  logger.info(`Opening database at ${dbPath}`);
-  const db = new Database(dbPath);
-
-  db.pragma('journal_mode = WAL');
-  db.pragma('synchronous = NORMAL');
-  db.pragma('cache_size = 10000');
-  db.pragma('foreign_keys = ON');
-
-  return db;
-}

package/src/index.ts

@@ -1,35 +0,0 @@
-// ── Types ──────────────────────────────────────────────────
-export type { IpcMessage } from './types/ipc.types.js';
-
-// ── Utils ──────────────────────────────────────────────────
-export { sha256 } from './utils/hash.js';
-export { createLogger, getLogger, resetLogger } from './utils/logger.js';
-export type { LoggerOptions } from './utils/logger.js';
-export { normalizePath, getDataDir, getPipeName } from './utils/paths.js';
-export { TypedEventBus } from './utils/events.js';
-
-// ── DB ─────────────────────────────────────────────────────
-export { createConnection } from './db/connection.js';
-
-// ── IPC ────────────────────────────────────────────────────
-export { encodeMessage, MessageDecoder } from './ipc/protocol.js';
-export { IpcServer } from './ipc/server.js';
-export type { IpcRouter } from './ipc/server.js';
-export { IpcClient } from './ipc/client.js';
-
-// ── MCP ────────────────────────────────────────────────────
-export { startMcpServer } from './mcp/server.js';
-export type { McpServerOptions } from './mcp/server.js';
-export { McpHttpServer } from './mcp/http-server.js';
-export type { McpHttpServerOptions } from './mcp/http-server.js';
-
-// ── CLI ────────────────────────────────────────────────────
-export { c, baseIcons, header, keyValue, statusBadge, progressBar, divider, table, stripAnsi } from './cli/colors.js';
-
-// ── API ────────────────────────────────────────────────────
-export { BaseApiServer } from './api/server.js';
-export type { ApiServerOptions, RouteDefinition } from './api/server.js';
-
-// ── Cross-Brain ────────────────────────────────────────────
-export { CrossBrainClient } from './cross-brain/client.js';
-export type { BrainPeer } from './cross-brain/client.js';

package/src/ipc/client.ts

@@ -1,117 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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/server.ts

@@ -1,170 +0,0 @@
-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';
-
-export interface IpcRouter {
-  handle(method: string, params: unknown): unknown;
-  listMethods(): string[];
-}
-
-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,
-    private daemonName: string = 'brain',
-  ) {}
-
-  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: ${this.daemonName} 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');
-  }
-}