@timmeck/marketing-brain 0.2.0

package/src/research/research-engine.ts

@@ -0,0 +1,226 @@
+import type { ResearchConfig } 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 { CampaignRepository } from '../db/repositories/campaign.repository.js';
+import type { TemplateRepository } from '../db/repositories/template.repository.js';
+import type { InsightRepository } from '../db/repositories/insight.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import { engagementScore } from '../learning/confidence-scorer.js';
+import { getLogger } from '../utils/logger.js';
+
+export class ResearchEngine {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private logger = getLogger();
+
+  constructor(
+    private config: ResearchConfig,
+    private postRepo: PostRepository,
+    private engagementRepo: EngagementRepository,
+    private campaignRepo: CampaignRepository,
+    private templateRepo: TemplateRepository,
+    private insightRepo: InsightRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  start(): void {
+    // Initial delay before first run
+    setTimeout(() => {
+      this.runCycle();
+      this.timer = setInterval(() => {
+        try {
+          this.runCycle();
+        } catch (err) {
+          this.logger.error('Research cycle error:', err);
+        }
+      }, this.config.intervalMs);
+    }, this.config.initialDelayMs);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  runCycle(): void {
+    this.logger.info('Starting research cycle');
+
+    // Expire old insights
+    const expired = this.insightRepo.expireOld();
+    if (expired > 0) this.logger.info(`Expired ${expired} old insights`);
+
+    // Generate new insights
+    this.detectTrends();
+    this.detectGaps();
+    this.detectSynergies();
+    this.suggestTemplates();
+    this.suggestOptimizations();
+
+    this.logger.info('Research cycle complete');
+  }
+
+  private detectTrends(): void {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - this.config.trendWindowDays);
+    const recentPosts = this.postRepo.recentPublished(cutoff.toISOString());
+
+    if (recentPosts.length < this.config.minDataPoints) return;
+
+    // Detect platform engagement trends
+    const platformScores: Record<string, number[]> = {};
+    for (const post of recentPosts) {
+      const eng = this.engagementRepo.getLatestByPost(post.id);
+      if (!eng) continue;
+      const score = engagementScore(eng);
+      if (!platformScores[post.platform]) platformScores[post.platform] = [];
+      platformScores[post.platform].push(score);
+    }
+
+    for (const [platform, scores] of Object.entries(platformScores)) {
+      if (scores.length < 3) continue;
+      const avg = scores.reduce((a, b) => a + b, 0) / scores.length;
+      const recentAvg = scores.slice(0, Math.ceil(scores.length / 2)).reduce((a, b) => a + b, 0) / Math.ceil(scores.length / 2);
+      const olderAvg = scores.slice(Math.ceil(scores.length / 2)).reduce((a, b) => a + b, 0) / Math.floor(scores.length / 2);
+
+      if (olderAvg > 0 && Math.abs(recentAvg - olderAvg) / olderAvg > 0.2) {
+        const direction = recentAvg > olderAvg ? 'up' : 'down';
+        const pct = Math.round(Math.abs(recentAvg - olderAvg) / olderAvg * 100);
+
+        this.insightRepo.create({
+          type: 'trend',
+          title: `${platform} engagement trending ${direction}`,
+          description: `Engagement on ${platform} is ${direction} ${pct}% over the last ${this.config.trendWindowDays} days (avg score: ${avg.toFixed(0)})`,
+          confidence: Math.min(0.9, scores.length / 20),
+          priority: pct > 30 ? 8 : 5,
+          expires_at: this.expiresAt(),
+        });
+      }
+    }
+  }
+
+  private detectGaps(): void {
+    const platforms = ['x', 'reddit', 'linkedin', 'bluesky'];
+    const postsByPlatform = this.postRepo.countByPlatform();
+
+    for (const platform of platforms) {
+      if (!postsByPlatform[platform] || postsByPlatform[platform] === 0) {
+        this.insightRepo.create({
+          type: 'gap',
+          title: `No posts on ${platform}`,
+          description: `You haven't posted on ${platform} yet. Consider expanding your reach to this platform.`,
+          confidence: 0.8,
+          priority: 4,
+          expires_at: this.expiresAt(),
+        });
+      } else if (postsByPlatform[platform] < 3) {
+        this.insightRepo.create({
+          type: 'gap',
+          title: `Low activity on ${platform}`,
+          description: `Only ${postsByPlatform[platform]} posts on ${platform}. Increasing frequency could improve visibility.`,
+          confidence: 0.6,
+          priority: 3,
+          expires_at: this.expiresAt(),
+        });
+      }
+    }
+  }
+
+  private detectSynergies(): void {
+    const topPosts = this.engagementRepo.topPosts(20);
+
+    // Look for patterns in top posts
+    const platformFormat: Record<string, Record<string, number>> = {};
+    for (const post of topPosts) {
+      const fullPost = this.postRepo.getById(post.post_id);
+      if (!fullPost) continue;
+
+      const key = fullPost.platform;
+      if (!platformFormat[key]) platformFormat[key] = {};
+      const format = fullPost.format;
+      platformFormat[key][format] = (platformFormat[key][format] ?? 0) + 1;
+    }
+
+    for (const [platform, formats] of Object.entries(platformFormat)) {
+      const sorted = Object.entries(formats).sort(([, a], [, b]) => b - a);
+      if (sorted[0] && sorted[0][1] >= 3) {
+        this.insightRepo.create({
+          type: 'synergy',
+          title: `${sorted[0][0]} works best on ${platform}`,
+          description: `${sorted[0][1]} of your top posts on ${platform} use the ${sorted[0][0]} format. This combination consistently performs well.`,
+          confidence: sorted[0][1] / topPosts.length,
+          priority: 6,
+          expires_at: this.expiresAt(),
+        });
+      }
+    }
+  }
+
+  private suggestTemplates(): void {
+    const topPosts = this.engagementRepo.topPosts(10);
+
+    for (const post of topPosts) {
+      const fullPost = this.postRepo.getById(post.post_id);
+      if (!fullPost) continue;
+
+      // Check if a template already exists for similar structure
+      const existing = this.templateRepo.search(fullPost.format, 1);
+      if (existing.length > 0) continue;
+
+      // If top post has no matching template, suggest creating one
+      this.insightRepo.create({
+        type: 'template',
+        title: `Create template from top ${fullPost.platform} post`,
+        description: `Post #${fullPost.id} (${fullPost.format}) has high engagement. Consider extracting its structure as a reusable template.`,
+        confidence: 0.7,
+        priority: 5,
+        expires_at: this.expiresAt(),
+      });
+    }
+  }
+
+  private suggestOptimizations(): void {
+    const campaigns = this.campaignRepo.listActive();
+
+    for (const campaign of campaigns) {
+      const posts = this.postRepo.listByCampaign(campaign.id, 50);
+      if (posts.length < 3) continue;
+
+      let totalScore = 0;
+      let postCount = 0;
+      for (const post of posts) {
+        const eng = this.engagementRepo.getLatestByPost(post.id);
+        if (!eng) continue;
+        totalScore += engagementScore(eng);
+        postCount++;
+      }
+
+      if (postCount === 0) continue;
+      const avgScore = totalScore / postCount;
+
+      // Suggest cross-posting top content
+      const topPost = this.engagementRepo.topPosts(1);
+      if (topPost.length > 0 && topPost[0]) {
+        const top = topPost[0];
+        const topFullPost = this.postRepo.getById(top.post_id);
+        if (topFullPost && topFullPost.campaign_id === campaign.id) {
+          this.insightRepo.create({
+            type: 'optimization',
+            title: `Cross-post top content from "${campaign.name}"`,
+            description: `Your top post in "${campaign.name}" (score: ${engagementScore(top).toFixed(0)}) could be adapted for other platforms. Campaign avg: ${avgScore.toFixed(0)}.`,
+            confidence: 0.6,
+            priority: 4,
+            campaign_id: campaign.id,
+            expires_at: this.expiresAt(),
+          });
+        }
+      }
+    }
+  }
+
+  private expiresAt(): string {
+    const d = new Date();
+    d.setDate(d.getDate() + this.config.insightExpiryDays);
+    return d.toISOString();
+  }
+}

package/src/services/analytics.service.ts

@@ -0,0 +1,73 @@
+import type { PostRepository } from '../db/repositories/post.repository.js';
+import type { EngagementRepository } from '../db/repositories/engagement.repository.js';
+import type { CampaignRepository } from '../db/repositories/campaign.repository.js';
+import type { StrategyRepository } from '../db/repositories/strategy.repository.js';
+import type { RuleRepository } from '../db/repositories/rule.repository.js';
+import type { TemplateRepository } from '../db/repositories/template.repository.js';
+import type { InsightRepository } from '../db/repositories/insight.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+
+export class AnalyticsService {
+  constructor(
+    private postRepo: PostRepository,
+    private engagementRepo: EngagementRepository,
+    private campaignRepo: CampaignRepository,
+    private strategyRepo: StrategyRepository,
+    private ruleRepo: RuleRepository,
+    private templateRepo: TemplateRepository,
+    private insightRepo: InsightRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  getSummary() {
+    const network = this.synapseManager.getNetworkStats();
+
+    return {
+      posts: {
+        total: this.postRepo.countAll(),
+        byPlatform: this.postRepo.countByPlatform(),
+        byStatus: this.postRepo.countByStatus(),
+      },
+      campaigns: {
+        total: this.campaignRepo.countAll(),
+      },
+      strategies: {
+        total: this.strategyRepo.countAll(),
+      },
+      rules: {
+        total: this.ruleRepo.countAll(),
+        active: this.ruleRepo.countActive(),
+      },
+      templates: {
+        total: this.templateRepo.countAll(),
+      },
+      insights: {
+        active: this.insightRepo.countActive(),
+        total: this.insightRepo.countAll(),
+      },
+      network: {
+        synapses: network.totalSynapses,
+        nodes: network.totalNodes,
+        avgWeight: network.avgWeight,
+      },
+    };
+  }
+
+  getTopPerformers(limit: number = 10) {
+    return {
+      topPosts: this.engagementRepo.topPosts(limit),
+      platformStats: this.engagementRepo.avgByPlatform(),
+      topStrategies: this.strategyRepo.topByConfidence(0.6, limit),
+    };
+  }
+
+  getDashboardData() {
+    return {
+      summary: this.getSummary(),
+      topPerformers: this.getTopPerformers(5),
+      recentInsights: this.insightRepo.listActive(5),
+      activeRules: this.ruleRepo.listActive(),
+      strongestConnections: this.synapseManager.getStrongestSynapses(10),
+    };
+  }
+}

package/src/services/audience.service.ts

@@ -0,0 +1,40 @@
+import type { AudienceRepository } from '../db/repositories/audience.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { Audience } from '../types/post.types.js';
+
+export class AudienceService {
+  constructor(
+    private audienceRepo: AudienceRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  create(data: { name: string; platform?: string; demographics?: string; interests?: string }): Audience {
+    const existing = this.audienceRepo.getByName(data.name);
+    if (existing) return existing;
+
+    const id = this.audienceRepo.create(data);
+    return this.audienceRepo.getById(id)!;
+  }
+
+  linkToPost(audienceId: number, postId: number): void {
+    this.synapseManager.strengthen(
+      { type: 'post', id: postId },
+      { type: 'audience', id: audienceId },
+      'engages_with',
+    );
+  }
+
+  getById(id: number): Audience | undefined {
+    return this.audienceRepo.getById(id);
+  }
+
+  listAll(): Audience[] {
+    return this.audienceRepo.listAll();
+  }
+
+  getStats() {
+    return {
+      total: this.audienceRepo.countAll(),
+    };
+  }
+}

package/src/services/campaign.service.ts

@@ -0,0 +1,80 @@
+import type { CampaignRepository } from '../db/repositories/campaign.repository.js';
+import type { PostRepository } from '../db/repositories/post.repository.js';
+import type { EngagementRepository } from '../db/repositories/engagement.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { Campaign, CampaignCreate } from '../types/post.types.js';
+import { getEventBus } from '../utils/events.js';
+
+export class CampaignService {
+  constructor(
+    private campaignRepo: CampaignRepository,
+    private postRepo: PostRepository,
+    private engagementRepo: EngagementRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  create(data: CampaignCreate): Campaign {
+    const existing = this.campaignRepo.getByName(data.name);
+    if (existing) return existing;
+
+    const id = this.campaignRepo.create(data);
+    const campaign = this.campaignRepo.getById(id)!;
+
+    getEventBus().emit('campaign:created', { campaignId: id, name: data.name });
+    return campaign;
+  }
+
+  getById(id: number): Campaign | undefined {
+    return this.campaignRepo.getById(id);
+  }
+
+  getByName(name: string): Campaign | undefined {
+    return this.campaignRepo.getByName(name);
+  }
+
+  listCampaigns(): Campaign[] {
+    return this.campaignRepo.listAll();
+  }
+
+  getStats(campaignId: number) {
+    const campaign = this.campaignRepo.getById(campaignId);
+    if (!campaign) return null;
+
+    const posts = this.postRepo.listByCampaign(campaignId, 1000);
+    let totalLikes = 0, totalComments = 0, totalShares = 0, totalImpressions = 0;
+
+    for (const post of posts) {
+      const eng = this.engagementRepo.getLatestByPost(post.id);
+      if (eng) {
+        totalLikes += eng.likes;
+        totalComments += eng.comments;
+        totalShares += eng.shares;
+        totalImpressions += eng.impressions;
+      }
+    }
+
+    return {
+      campaign,
+      postCount: posts.length,
+      totalLikes,
+      totalComments,
+      totalShares,
+      totalImpressions,
+      avgEngagement: posts.length > 0
+        ? (totalLikes + totalComments * 3 + totalShares * 5) / posts.length
+        : 0,
+    };
+  }
+
+  update(id: number, data: Partial<Campaign>): boolean {
+    return this.campaignRepo.update(id, data);
+  }
+
+  crossPromote(campaignA: number, campaignB: number): void {
+    this.synapseManager.strengthen(
+      { type: 'campaign', id: campaignA },
+      { type: 'campaign', id: campaignB },
+      'cross_promotes',
+    );
+  }
+}

package/src/services/insight.service.ts

@@ -0,0 +1,54 @@
+import type { InsightRepository } from '../db/repositories/insight.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { Insight, InsightCreate } from '../types/post.types.js';
+import { getEventBus } from '../utils/events.js';
+
+export class InsightService {
+  constructor(
+    private insightRepo: InsightRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  create(data: InsightCreate): Insight {
+    const id = this.insightRepo.create(data);
+    const insight = this.insightRepo.getById(id)!;
+
+    if (data.campaign_id) {
+      this.synapseManager.strengthen(
+        { type: 'insight', id },
+        { type: 'campaign', id: data.campaign_id },
+        'informs',
+      );
+    }
+
+    getEventBus().emit('insight:created', { insightId: id, type: data.type });
+    return insight;
+  }
+
+  listActive(limit?: number): Insight[] {
+    return this.insightRepo.listActive(limit);
+  }
+
+  listByType(type: string, limit?: number): Insight[] {
+    return this.insightRepo.listByType(type, limit);
+  }
+
+  listByCampaign(campaignId: number): Insight[] {
+    return this.insightRepo.listByCampaign(campaignId);
+  }
+
+  deactivate(id: number): void {
+    this.insightRepo.deactivate(id);
+  }
+
+  expireOld(): number {
+    return this.insightRepo.expireOld();
+  }
+
+  getStats() {
+    return {
+      active: this.insightRepo.countActive(),
+      total: this.insightRepo.countAll(),
+    };
+  }
+}

package/src/services/post.service.ts

@@ -0,0 +1,116 @@
+import type { PostRepository } from '../db/repositories/post.repository.js';
+import type { EngagementRepository } from '../db/repositories/engagement.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { Post, PostCreate, EngagementCreate } from '../types/post.types.js';
+import { getEventBus } from '../utils/events.js';
+import { sha256 } from '../utils/hash.js';
+
+export class PostService {
+  constructor(
+    private postRepo: PostRepository,
+    private engagementRepo: EngagementRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  report(data: PostCreate): { post: Post; isNew: boolean } {
+    const fingerprint = sha256(`${data.platform}:${data.content}`);
+    const existing = this.postRepo.getByFingerprint(fingerprint);
+
+    if (existing) {
+      if (data.url && !existing.url) {
+        this.postRepo.update(existing.id, { url: data.url, status: 'published', published_at: data.published_at ?? new Date().toISOString() });
+      }
+      return { post: this.postRepo.getById(existing.id)!, isNew: false };
+    }
+
+    const id = this.postRepo.create(data);
+    const post = this.postRepo.getById(id)!;
+
+    if (post.campaign_id) {
+      this.synapseManager.strengthen(
+        { type: 'post', id: post.id },
+        { type: 'campaign', id: post.campaign_id },
+        'belongs_to',
+      );
+    }
+
+    getEventBus().emit('post:created', {
+      postId: post.id,
+      campaignId: post.campaign_id,
+      platform: post.platform,
+    });
+
+    return { post, isNew: true };
+  }
+
+  publish(postId: number, url?: string): Post | undefined {
+    const post = this.postRepo.getById(postId);
+    if (!post) return undefined;
+
+    this.postRepo.update(postId, {
+      status: 'published',
+      url: url ?? post.url,
+      published_at: new Date().toISOString(),
+    });
+
+    getEventBus().emit('post:published', { postId, platform: post.platform });
+    return this.postRepo.getById(postId);
+  }
+
+  updateEngagement(data: EngagementCreate): { engagementId: number; postId: number } {
+    const engagementId = this.engagementRepo.create(data);
+
+    getEventBus().emit('engagement:updated', { postId: data.post_id, engagementId });
+    return { engagementId, postId: data.post_id };
+  }
+
+  getById(id: number): Post | undefined {
+    return this.postRepo.getById(id);
+  }
+
+  listPosts(opts?: { platform?: string; campaignId?: number; limit?: number }): Post[] {
+    if (opts?.campaignId) return this.postRepo.listByCampaign(opts.campaignId, opts?.limit);
+    if (opts?.platform) return this.postRepo.listByPlatform(opts.platform, opts?.limit);
+    return this.postRepo.listAll(opts?.limit);
+  }
+
+  searchPosts(query: string, limit?: number): Post[] {
+    return this.postRepo.search(query, limit);
+  }
+
+  findSimilar(postId: number): Post[] {
+    const activated = this.synapseManager.activate({ type: 'post', id: postId });
+    const similarPostIds = activated
+      .filter(a => a.node.type === 'post' && a.node.id !== postId)
+      .slice(0, 10)
+      .map(a => a.node.id);
+
+    return similarPostIds
+      .map(id => this.postRepo.getById(id))
+      .filter((p): p is Post => p !== undefined);
+  }
+
+  getTopPosts(limit: number = 10) {
+    return this.engagementRepo.topPosts(limit);
+  }
+
+  getEngagement(postId: number) {
+    return this.engagementRepo.getLatestByPost(postId);
+  }
+
+  getEngagementHistory(postId: number) {
+    return this.engagementRepo.listByPost(postId);
+  }
+
+  getPlatformStats() {
+    return this.engagementRepo.avgByPlatform();
+  }
+
+  getPostStats() {
+    return {
+      total: this.postRepo.countAll(),
+      byPlatform: this.postRepo.countByPlatform(),
+      byStatus: this.postRepo.countByStatus(),
+    };
+  }
+}

package/src/services/rule.service.ts

@@ -0,0 +1,90 @@
+import type { RuleRepository } from '../db/repositories/rule.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { MarketingRule, RuleCreate } from '../types/post.types.js';
+import { getEventBus } from '../utils/events.js';
+
+export interface RuleCheckResult {
+  passed: boolean;
+  violations: Array<{
+    rule: MarketingRule;
+    reason: string;
+  }>;
+  recommendations: Array<{
+    rule: MarketingRule;
+    suggestion: string;
+  }>;
+}
+
+export class RuleService {
+  constructor(
+    private ruleRepo: RuleRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  create(data: RuleCreate): MarketingRule {
+    const id = this.ruleRepo.create(data);
+    const rule = this.ruleRepo.getById(id)!;
+
+    getEventBus().emit('rule:learned', { ruleId: id, pattern: data.pattern });
+    return rule;
+  }
+
+  check(content: string, platform: string): RuleCheckResult {
+    const rules = this.ruleRepo.listActive();
+    const violations: RuleCheckResult['violations'] = [];
+    const recommendations: RuleCheckResult['recommendations'] = [];
+
+    for (const rule of rules) {
+      const pattern = rule.pattern.toLowerCase();
+      const contentLower = content.toLowerCase();
+      const platformLower = platform.toLowerCase();
+
+      // Check if rule pattern matches
+      if (pattern.includes('platform:')) {
+        const rulePlatform = pattern.split('platform:')[1]?.split(' ')[0] ?? '';
+        if (rulePlatform && rulePlatform !== platformLower) continue;
+      }
+
+      if (pattern.includes('no_') || pattern.includes('avoid_') || pattern.includes('never_')) {
+        // Preventive rules
+        const keywords = pattern.replace(/no_|avoid_|never_/g, '').split('_');
+        const matches = keywords.some(kw => contentLower.includes(kw));
+        if (matches) {
+          violations.push({ rule, reason: rule.recommendation });
+        }
+      } else {
+        // Recommendation rules
+        recommendations.push({ rule, suggestion: rule.recommendation });
+      }
+    }
+
+    return {
+      passed: violations.length === 0,
+      violations,
+      recommendations: recommendations.slice(0, 5),
+    };
+  }
+
+  listRules(): MarketingRule[] {
+    return this.ruleRepo.listActive();
+  }
+
+  listAllRules(): MarketingRule[] {
+    return this.ruleRepo.listAll();
+  }
+
+  recordTrigger(ruleId: number, success: boolean): void {
+    this.ruleRepo.incrementTrigger(ruleId, success);
+  }
+
+  getById(id: number): MarketingRule | undefined {
+    return this.ruleRepo.getById(id);
+  }
+
+  getStats() {
+    return {
+      total: this.ruleRepo.countAll(),
+      active: this.ruleRepo.countActive(),
+    };
+  }
+}