@timmeck/marketing-brain 0.2.1 → 0.3.0

package/src/ipc/client.ts

@@ -1,110 +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>();
-
-  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));
-    });
-  }
-
-  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);
-      }
-    }
-  }
-}

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/router.ts

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

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

@@ -1,36 +0,0 @@
-/**
- * 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

@@ -1,254 +0,0 @@
-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',
-            );
-          }
-        }
-      }
-    }
-  }
-}