@timmeck/brain 1.0.0 → 1.1.1

package/src/ipc/client.ts

@@ -1,118 +1,118 @@
-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);
-        // Reject all pending requests
-        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);
-    }
-  }
-}
+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);
+        // Reject all pending requests
+        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 +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);
-  }
-}
+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

@@ -10,6 +10,7 @@ import type { SynapseService } from '../services/synapse.service.js';
 import type { ResearchService } from '../services/research.service.js';
 import type { NotificationService } from '../services/notification.service.js';
 import type { AnalyticsService } from '../services/analytics.service.js';
+import type { LearningEngine, LearningCycleResult } from '../learning/learning-engine.js';
 
 export interface Services {
   error: ErrorService;
@@ -21,6 +22,7 @@ export interface Services {
   research: ResearchService;
   notification: NotificationService;
   analytics: AnalyticsService;
+  learning?: LearningEngine;
 }
 
 type MethodHandler = (params: unknown) => unknown;
@@ -76,7 +78,7 @@ export class IpcRouter {
       ['code.analyze',            (params) => s.code.analyzeAndRegister(p(params))],
       ['code.find',               (params) => s.code.findReusable(p(params))],
       ['code.similarity',         (params) => s.code.checkSimilarity(p(params).source, p(params).language)],
-      ['code.modules',            (params) => s.code.listModules(p(params)?.projectId)],
+      ['code.modules',            (params) => s.code.listModules(p(params)?.projectId, p(params)?.language, p(params)?.limit)],
       ['code.get',                (params) => s.code.getById(p(params).id)],
 
       // Prevention
@@ -101,6 +103,12 @@ export class IpcRouter {
       // Analytics
       ['analytics.summary',       (params) => s.analytics.getSummary(p(params)?.projectId)],
       ['analytics.network',       (params) => s.analytics.getNetworkOverview(p(params)?.limit)],
+
+      // Learning
+      ['learning.run',            () => {
+        if (!s.learning) throw new Error('Learning engine not available');
+        return s.learning.runCycle();
+      }],
     ]);
   }
 }

package/src/ipc/server.ts

@@ -1,110 +1,110 @@
-import net from 'node:net';
-import { randomUUID } from 'node:crypto';
-import { getLogger } from '../utils/logger.js';
-
-const logger = getLogger();
-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>();
-
-  constructor(
-    private router: IpcRouter,
-    private pipeName: string,
-  ) {}
-
-  start(): void {
-    this.server = net.createServer((socket) => {
-      const clientId = randomUUID();
-      this.clients.set(clientId, socket);
-      const decoder = new MessageDecoder();
-
-      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', () => {
-        logger.info(`IPC client disconnected: ${clientId}`);
-        this.clients.delete(clientId);
-      });
-
-      socket.on('error', (err) => {
-        logger.error(`IPC client ${clientId} error:`, err);
-        this.clients.delete(clientId);
-      });
-    });
-
-    this.server.on('error', (err) => {
-      logger.error('IPC server error:', err);
-    });
-
-    this.server.listen(this.pipeName, () => {
-      logger.info(`IPC server 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;
-    logger.info('IPC server stopped');
-  }
-}
+import net from 'node:net';
+import { randomUUID } from 'node:crypto';
+import { getLogger } from '../utils/logger.js';
+
+const logger = getLogger();
+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>();
+
+  constructor(
+    private router: IpcRouter,
+    private pipeName: string,
+  ) {}
+
+  start(): void {
+    this.server = net.createServer((socket) => {
+      const clientId = randomUUID();
+      this.clients.set(clientId, socket);
+      const decoder = new MessageDecoder();
+
+      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', () => {
+        logger.info(`IPC client disconnected: ${clientId}`);
+        this.clients.delete(clientId);
+      });
+
+      socket.on('error', (err) => {
+        logger.error(`IPC client ${clientId} error:`, err);
+        this.clients.delete(clientId);
+      });
+    });
+
+    this.server.on('error', (err) => {
+      logger.error('IPC server error:', err);
+    });
+
+    this.server.listen(this.pipeName, () => {
+      logger.info(`IPC server 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;
+    logger.info('IPC server stopped');
+  }
+}

package/src/learning/confidence-scorer.ts

@@ -1,47 +1,47 @@
-/**
- * Wilson Score Interval for low-sample-size confidence.
- * Prevents unrealistic 100% from single success/failure.
- */
-export function wilsonScore(successes: number, total: number, z: number = 1.96): number {
-  if (total === 0) return 0;
-
-  const p = successes / total;
-  const z2 = z * z;
-  const n = total;
-
-  const numerator = p + z2 / (2 * n);
-  const denominator = 1 + z2 / n;
-  const margin = z * Math.sqrt((p * (1 - p) + z2 / (4 * n)) / n) / denominator;
-
-  // Lower bound of Wilson interval = conservative estimate
-  return Math.max(0, numerator / denominator - margin);
-}
-
-/**
- * Time-decayed confidence: recent successes count more.
- */
-export function timeDecayedConfidence(
-  successes: number,
-  total: number,
-  lastUsedAt: string,
-  halfLifeDays: number,
-): number {
-  const base = wilsonScore(successes, total);
-  const ageDays = (Date.now() - new Date(lastUsedAt).getTime()) / (1000 * 60 * 60 * 24);
-  const decay = Math.pow(0.5, ageDays / halfLifeDays);
-  return base * decay;
-}
-
-/**
- * Combined confidence from success rate + usage frequency + recency.
- */
-export function computeConfidence(
-  successCount: number,
-  failCount: number,
-  lastUsedAt: string,
-  halfLifeDays: number = 30,
-): number {
-  const total = successCount + failCount;
-  if (total === 0) return 0;
-  return timeDecayedConfidence(successCount, total, lastUsedAt, halfLifeDays);
-}
+/**
+ * Wilson Score Interval for low-sample-size confidence.
+ * Prevents unrealistic 100% from single success/failure.
+ */
+export function wilsonScore(successes: number, total: number, z: number = 1.96): number {
+  if (total === 0) return 0;
+
+  const p = successes / total;
+  const z2 = z * z;
+  const n = total;
+
+  const numerator = p + z2 / (2 * n);
+  const denominator = 1 + z2 / n;
+  const margin = z * Math.sqrt((p * (1 - p) + z2 / (4 * n)) / n) / denominator;
+
+  // Lower bound of Wilson interval = conservative estimate
+  return Math.max(0, numerator / denominator - margin);
+}
+
+/**
+ * Time-decayed confidence: recent successes count more.
+ */
+export function timeDecayedConfidence(
+  successes: number,
+  total: number,
+  lastUsedAt: string,
+  halfLifeDays: number,
+): number {
+  const base = wilsonScore(successes, total);
+  const ageDays = (Date.now() - new Date(lastUsedAt).getTime()) / (1000 * 60 * 60 * 24);
+  const decay = Math.pow(0.5, ageDays / halfLifeDays);
+  return base * decay;
+}
+
+/**
+ * Combined confidence from success rate + usage frequency + recency.
+ */
+export function computeConfidence(
+  successCount: number,
+  failCount: number,
+  lastUsedAt: string,
+  halfLifeDays: number = 30,
+): number {
+  const total = successCount + failCount;
+  if (total === 0) return 0;
+  return timeDecayedConfidence(successCount, total, lastUsedAt, halfLifeDays);
+}