@timmeck/marketing-brain 0.2.0

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,126 @@
+import { getLogger } from '../utils/logger.js';
+
+const logger = getLogger();
+import type { PostService } from '../services/post.service.js';
+import type { CampaignService } from '../services/campaign.service.js';
+import type { StrategyService } from '../services/strategy.service.js';
+import type { TemplateService } from '../services/template.service.js';
+import type { RuleService } from '../services/rule.service.js';
+import type { AudienceService } from '../services/audience.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';
+
+export interface Services {
+  post: PostService;
+  campaign: CampaignService;
+  strategy: StrategyService;
+  template: TemplateService;
+  rule: RuleService;
+  audience: AudienceService;
+  synapse: SynapseService;
+  analytics: AnalyticsService;
+  insight: InsightService;
+  learning?: LearningEngine;
+}
+
+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 [...this.methods.keys()];
+  }
+
+  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>([
+      // Posts
+      ['post.report',          (params) => s.post.report(p(params))],
+      ['post.publish',         (params) => s.post.publish(p(params).id ?? p(params).postId, p(params).url)],
+      ['post.get',             (params) => s.post.getById(p(params).id)],
+      ['post.list',            (params) => s.post.listPosts(p(params))],
+      ['post.search',          (params) => s.post.searchPosts(p(params).query, p(params).limit)],
+      ['post.similar',         (params) => s.post.findSimilar(p(params).id ?? p(params).postId)],
+      ['post.engagement',      (params) => s.post.updateEngagement(p(params))],
+      ['post.getEngagement',   (params) => s.post.getEngagement(p(params).id ?? p(params).postId)],
+      ['post.top',             (params) => s.post.getTopPosts(p(params)?.limit)],
+      ['post.stats',           () => s.post.getPostStats()],
+      ['post.platformStats',   () => s.post.getPlatformStats()],
+
+      // Campaigns
+      ['campaign.create',      (params) => s.campaign.create(p(params))],
+      ['campaign.get',         (params) => s.campaign.getById(p(params).id)],
+      ['campaign.list',        () => s.campaign.listCampaigns()],
+      ['campaign.stats',       (params) => s.campaign.getStats(p(params).id ?? p(params).campaignId)],
+      ['campaign.update',      (params) => s.campaign.update(p(params).id, p(params))],
+
+      // Strategies
+      ['strategy.report',      (params) => s.strategy.report(p(params))],
+      ['strategy.suggest',     (params) => s.strategy.suggest(p(params).query, p(params).limit)],
+      ['strategy.top',         (params) => s.strategy.getTopStrategies(p(params)?.minConfidence, p(params)?.limit)],
+      ['strategy.list',        (params) => s.strategy.listAll(p(params)?.limit)],
+
+      // Templates
+      ['template.find',        (params) => s.template.find(p(params).query, p(params).limit)],
+      ['template.create',      (params) => s.template.create(p(params))],
+      ['template.list',        (params) => s.template.listAll(p(params)?.limit)],
+      ['template.byPlatform',  (params) => s.template.findByPlatform(p(params).platform, p(params).limit)],
+      ['template.use',         (params) => s.template.useTemplate(p(params).templateId, p(params).postId)],
+
+      // Rules
+      ['rule.check',           (params) => s.rule.check(p(params).content, p(params).platform)],
+      ['rule.list',            () => s.rule.listRules()],
+      ['rule.create',          (params) => s.rule.create(p(params))],
+
+      // Audiences
+      ['audience.create',      (params) => s.audience.create(p(params))],
+      ['audience.list',        () => s.audience.listAll()],
+      ['audience.linkPost',    (params) => s.audience.linkToPost(p(params).audienceId, p(params).postId)],
+
+      // Insights
+      ['insight.list',         (params) => s.insight.listActive(p(params)?.limit)],
+      ['insight.byType',       (params) => s.insight.listByType(p(params).type, p(params).limit)],
+      ['insight.byCampaign',   (params) => s.insight.listByCampaign(p(params).campaignId)],
+
+      // Synapses
+      ['synapse.context',      (params) => s.synapse.getPostContext(p(params).postId ?? p(params).id)],
+      ['synapse.path',         (params) => s.synapse.findPath(p(params).fromType, p(params).fromId, p(params).toType, p(params).toId)],
+      ['synapse.related',      (params) => s.synapse.getRelated(p(params))],
+      ['synapse.stats',        () => s.synapse.getNetworkStats()],
+      ['synapse.strongest',    (params) => s.synapse.getStrongest(p(params)?.limit)],
+
+      // Analytics
+      ['analytics.summary',    () => s.analytics.getSummary()],
+      ['analytics.top',        (params) => s.analytics.getTopPerformers(p(params)?.limit)],
+      ['analytics.dashboard',  () => s.analytics.getDashboardData()],
+
+      // Learning
+      ['learning.run',         () => {
+        if (!s.learning) throw new Error('Learning engine not available');
+        return s.learning.runCycle();
+      }],
+    ]);
+  }
+}

package/src/ipc/server.ts

@@ -0,0 +1,140 @@
+import net from 'node:net';
+import fs from 'node:fs';
+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.createServer();
+    this.listen();
+  }
+
+  private createServer(): 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);
+      });
+    });
+  }
+
+  private listen(retried = false): void {
+    if (!this.server) return;
+
+    this.server.on('error', (err: NodeJS.ErrnoException) => {
+      if (err.code === 'EADDRINUSE' && !retried) {
+        logger.warn(`IPC pipe in use, attempting to recover: ${this.pipeName}`);
+        this.recoverStalePipe();
+      } else {
+        logger.error('IPC server error:', err);
+      }
+    });
+
+    this.server.listen(this.pipeName, () => {
+      logger.info(`IPC server listening on ${this.pipeName}`);
+    });
+  }
+
+  private recoverStalePipe(): void {
+    const probe = net.createConnection(this.pipeName);
+
+    probe.on('connect', () => {
+      probe.destroy();
+      logger.error('IPC pipe is held by another running daemon. Stop it first with: marketing stop');
+    });
+
+    probe.on('error', () => {
+      probe.destroy();
+      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) => {
+        logger.error('IPC server error after recovery:', err);
+      });
+      this.server!.listen(this.pipeName, () => {
+        logger.info(`IPC server recovered and listening on ${this.pipeName}`);
+      });
+    });
+
+    probe.setTimeout(2000, () => {
+      probe.destroy();
+      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) => {
+        logger.error('IPC server error after timeout recovery:', err);
+      });
+      this.server!.listen(this.pipeName, () => {
+        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));
+    }
+  }
+
+  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

@@ -0,0 +1,36 @@
+/**
+ * Wilson Score Interval — lower bound for confidence scoring.
+ * Used to evaluate rule confidence based on trigger/success counts.
+ */
+export function wilsonScore(successes: number, total: number, z: number = 1.96): number {
+  if (total === 0) return 0;
+
+  const p = successes / total;
+  const denominator = 1 + z * z / total;
+  const centre = p + z * z / (2 * total);
+  const offset = z * Math.sqrt((p * (1 - p) + z * z / (4 * total)) / total);
+
+  return (centre - offset) / denominator;
+}
+
+/**
+ * Compute engagement score from raw metrics.
+ * Weights: shares > comments > clicks > likes > impressions
+ */
+export function engagementScore(metrics: {
+  likes?: number;
+  comments?: number;
+  shares?: number;
+  impressions?: number;
+  clicks?: number;
+  saves?: number;
+}): number {
+  return (
+    (metrics.likes ?? 0) * 1 +
+    (metrics.comments ?? 0) * 3 +
+    (metrics.shares ?? 0) * 5 +
+    (metrics.clicks ?? 0) * 2 +
+    (metrics.saves ?? 0) * 4 +
+    (metrics.impressions ?? 0) * 0.01
+  );
+}

package/src/learning/learning-engine.ts

@@ -0,0 +1,254 @@
+import type { LearningConfig } from '../types/config.types.js';
+import type { PostRepository } from '../db/repositories/post.repository.js';
+import type { EngagementRepository } from '../db/repositories/engagement.repository.js';
+import type { RuleRepository } from '../db/repositories/rule.repository.js';
+import type { StrategyRepository } from '../db/repositories/strategy.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import { wilsonScore, engagementScore } from './confidence-scorer.js';
+import { getLogger } from '../utils/logger.js';
+
+export interface LearningCycleResult {
+  rulesCreated: number;
+  rulesUpdated: number;
+  strategiesUpdated: number;
+  synapsesDecayed: number;
+  synapsesPruned: number;
+}
+
+export class LearningEngine {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private logger = getLogger();
+
+  constructor(
+    private config: LearningConfig,
+    private postRepo: PostRepository,
+    private engagementRepo: EngagementRepository,
+    private ruleRepo: RuleRepository,
+    private strategyRepo: StrategyRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  start(): void {
+    this.timer = setInterval(() => {
+      try {
+        this.runCycle();
+      } catch (err) {
+        this.logger.error('Learning cycle error:', err);
+      }
+    }, this.config.intervalMs);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  runCycle(): LearningCycleResult {
+    this.logger.info('Starting learning cycle');
+    const result: LearningCycleResult = {
+      rulesCreated: 0,
+      rulesUpdated: 0,
+      strategiesUpdated: 0,
+      synapsesDecayed: 0,
+      synapsesPruned: 0,
+    };
+
+    // 1. Analyze recent posts for patterns
+    result.rulesCreated += this.extractTimingPatterns();
+    result.rulesCreated += this.extractFormatPatterns();
+    result.rulesCreated += this.extractPlatformPatterns();
+
+    // 2. Update strategy confidence based on engagement
+    result.strategiesUpdated = this.updateStrategyConfidence();
+
+    // 3. Update rule confidence via Wilson Score
+    result.rulesUpdated = this.updateRuleConfidence();
+
+    // 4. Run synapse decay
+    const decay = this.synapseManager.runDecay();
+    result.synapsesDecayed = decay.decayed;
+    result.synapsesPruned = decay.pruned;
+
+    // 5. Wire similar posts
+    this.wireSimilarPosts();
+
+    this.logger.info(`Learning cycle complete: ${JSON.stringify(result)}`);
+    return result;
+  }
+
+  private extractTimingPatterns(): number {
+    let created = 0;
+    const recentPosts = this.postRepo.listPublished(100);
+
+    // Group by hour of day
+    const hourBuckets: Record<number, { total: number; avgScore: number }> = {};
+
+    for (const post of recentPosts) {
+      if (!post.published_at) continue;
+      const hour = new Date(post.published_at).getHours();
+      const eng = this.engagementRepo.getLatestByPost(post.id);
+      if (!eng) continue;
+
+      const score = engagementScore(eng);
+      if (!hourBuckets[hour]) hourBuckets[hour] = { total: 0, avgScore: 0 };
+      hourBuckets[hour].total++;
+      hourBuckets[hour].avgScore += score;
+    }
+
+    // Find best/worst hours
+    for (const [hour, data] of Object.entries(hourBuckets)) {
+      if (data.total < this.config.minOccurrences) continue;
+      data.avgScore /= data.total;
+    }
+
+    const hours = Object.entries(hourBuckets)
+      .filter(([, d]) => d.total >= this.config.minOccurrences)
+      .sort(([, a], [, b]) => b.avgScore - a.avgScore);
+
+    if (hours.length >= 2) {
+      const bestHour = hours[0];
+      const worstHour = hours[hours.length - 1];
+
+      if (bestHour && worstHour && bestHour[1].avgScore > worstHour[1].avgScore * 2) {
+        this.ruleRepo.create({
+          pattern: `best_time_${bestHour[0]}h`,
+          recommendation: `Posts around ${bestHour[0]}:00 perform ${(bestHour[1].avgScore / Math.max(1, worstHour[1].avgScore)).toFixed(1)}x better than ${worstHour[0]}:00`,
+          confidence: wilsonScore(bestHour[1].total, recentPosts.length),
+        });
+        created++;
+      }
+    }
+
+    return created;
+  }
+
+  private extractFormatPatterns(): number {
+    let created = 0;
+    const recentPosts = this.postRepo.listPublished(100);
+
+    const formatBuckets: Record<string, { total: number; avgScore: number }> = {};
+
+    for (const post of recentPosts) {
+      const eng = this.engagementRepo.getLatestByPost(post.id);
+      if (!eng) continue;
+
+      const score = engagementScore(eng);
+      if (!formatBuckets[post.format]) formatBuckets[post.format] = { total: 0, avgScore: 0 };
+      formatBuckets[post.format].total++;
+      formatBuckets[post.format].avgScore += score;
+    }
+
+    for (const [format, data] of Object.entries(formatBuckets)) {
+      if (data.total < this.config.minOccurrences) continue;
+      data.avgScore /= data.total;
+    }
+
+    const formats = Object.entries(formatBuckets)
+      .filter(([, d]) => d.total >= this.config.minOccurrences)
+      .sort(([, a], [, b]) => b.avgScore - a.avgScore);
+
+    if (formats.length >= 2 && formats[0]) {
+      const [bestFormat, bestData] = formats[0];
+      this.ruleRepo.create({
+        pattern: `best_format_${bestFormat}`,
+        recommendation: `${bestFormat} posts average ${bestData.avgScore.toFixed(0)} engagement score (best format)`,
+        confidence: wilsonScore(bestData.total, recentPosts.length),
+      });
+      created++;
+    }
+
+    return created;
+  }
+
+  private extractPlatformPatterns(): number {
+    let created = 0;
+    const platformStats = this.engagementRepo.avgByPlatform();
+
+    if (platformStats.length >= 2) {
+      const toScore = (p: typeof platformStats[number]) => engagementScore({
+        likes: p.avg_likes, comments: p.avg_comments,
+        shares: p.avg_shares, impressions: p.avg_impressions, clicks: p.avg_clicks,
+      });
+      const sorted = [...platformStats].sort((a, b) => toScore(b) - toScore(a));
+      const best = sorted[0];
+      if (best && best.post_count >= this.config.minOccurrences) {
+        this.ruleRepo.create({
+          pattern: `best_platform_${best.platform}`,
+          recommendation: `${best.platform} is your top-performing platform (${best.post_count} posts, avg ${best.avg_likes.toFixed(0)} likes)`,
+          confidence: wilsonScore(best.post_count, platformStats.reduce((s, p) => s + p.post_count, 0)),
+        });
+        created++;
+      }
+    }
+
+    return created;
+  }
+
+  private updateStrategyConfidence(): number {
+    let updated = 0;
+    const strategies = this.strategyRepo.listAll(100);
+
+    for (const strategy of strategies) {
+      if (!strategy.post_id) continue;
+      const eng = this.engagementRepo.getLatestByPost(strategy.post_id);
+      if (!eng) continue;
+
+      const score = engagementScore(eng);
+      // Normalize: 0-10 → 0.0-1.0 confidence
+      const newConfidence = Math.min(1.0, score / 100);
+
+      if (Math.abs(newConfidence - strategy.confidence) > 0.05) {
+        this.strategyRepo.update(strategy.id, { confidence: newConfidence });
+        updated++;
+      }
+    }
+
+    return updated;
+  }
+
+  private updateRuleConfidence(): number {
+    let updated = 0;
+    const rules = this.ruleRepo.listAll();
+
+    for (const rule of rules) {
+      if (rule.trigger_count < this.config.minOccurrences) continue;
+
+      const newConfidence = wilsonScore(rule.success_count, rule.trigger_count);
+
+      if (newConfidence < this.config.pruneThreshold && rule.active) {
+        this.ruleRepo.update(rule.id, { active: 0, confidence: newConfidence });
+        updated++;
+      } else if (Math.abs(newConfidence - rule.confidence) > 0.05) {
+        this.ruleRepo.update(rule.id, { confidence: newConfidence });
+        updated++;
+      }
+    }
+
+    return updated;
+  }
+
+  private wireSimilarPosts(): void {
+    const posts = this.postRepo.listPublished(50);
+
+    for (let i = 0; i < posts.length; i++) {
+      for (let j = i + 1; j < Math.min(i + 5, posts.length); j++) {
+        const a = posts[i]!;
+        const b = posts[j]!;
+
+        // Simple similarity: same platform, similar content length, similar hashtags
+        if (a.platform === b.platform) {
+          const lengthRatio = Math.min(a.content.length, b.content.length) / Math.max(a.content.length, b.content.length);
+          if (lengthRatio > 0.5) {
+            this.synapseManager.strengthen(
+              { type: 'post', id: a.id },
+              { type: 'post', id: b.id },
+              'similar_to',
+            );
+          }
+        }
+      }
+    }
+  }
+}