@timmeck/marketing-brain 0.2.0

package/src/marketing-core.ts

@@ -0,0 +1,285 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import type Database from 'better-sqlite3';
+import { loadConfig } from './config.js';
+import type { MarketingBrainConfig } from './types/config.types.js';
+import { createLogger, getLogger } from './utils/logger.js';
+import { getEventBus } from './utils/events.js';
+import { createConnection } from './db/connection.js';
+import { runMigrations } from './db/migrations/index.js';
+
+// Repositories
+import { PostRepository } from './db/repositories/post.repository.js';
+import { EngagementRepository } from './db/repositories/engagement.repository.js';
+import { CampaignRepository } from './db/repositories/campaign.repository.js';
+import { StrategyRepository } from './db/repositories/strategy.repository.js';
+import { RuleRepository } from './db/repositories/rule.repository.js';
+import { TemplateRepository } from './db/repositories/template.repository.js';
+import { AudienceRepository } from './db/repositories/audience.repository.js';
+import { SynapseRepository } from './db/repositories/synapse.repository.js';
+import { InsightRepository } from './db/repositories/insight.repository.js';
+
+// Services
+import { PostService } from './services/post.service.js';
+import { CampaignService } from './services/campaign.service.js';
+import { StrategyService } from './services/strategy.service.js';
+import { TemplateService } from './services/template.service.js';
+import { RuleService } from './services/rule.service.js';
+import { AudienceService } from './services/audience.service.js';
+import { SynapseService } from './services/synapse.service.js';
+import { AnalyticsService } from './services/analytics.service.js';
+import { InsightService } from './services/insight.service.js';
+
+// Synapses
+import { SynapseManager } from './synapses/synapse-manager.js';
+
+// Engines
+import { LearningEngine } from './learning/learning-engine.js';
+import { ResearchEngine } from './research/research-engine.js';
+
+// IPC
+import { IpcRouter, type Services } from './ipc/router.js';
+import { IpcServer } from './ipc/server.js';
+
+// API
+import { ApiServer } from './api/server.js';
+
+// Dashboard
+import { DashboardServer } from './dashboard/server.js';
+import { renderDashboard } from './dashboard/renderer.js';
+
+export class MarketingCore {
+  private db: Database.Database | null = null;
+  private ipcServer: IpcServer | null = null;
+  private apiServer: ApiServer | null = null;
+  private dashboardServer: DashboardServer | null = null;
+  private learningEngine: LearningEngine | null = null;
+  private researchEngine: ResearchEngine | null = null;
+  private config: MarketingBrainConfig | null = null;
+  private configPath?: string;
+  private restarting = false;
+
+  start(configPath?: string): void {
+    this.configPath = configPath;
+    // 1. Config
+    this.config = loadConfig(configPath);
+    const config = this.config;
+
+    // 2. Ensure data dir
+    fs.mkdirSync(path.dirname(config.dbPath), { recursive: true });
+
+    // 3. Logger
+    createLogger({
+      level: config.log.level,
+      file: config.log.file,
+      maxSize: config.log.maxSize,
+      maxFiles: config.log.maxFiles,
+    });
+    const logger = getLogger();
+
+    // 4. Database
+    this.db = createConnection(config.dbPath);
+    runMigrations(this.db);
+    logger.info(`Database initialized: ${config.dbPath}`);
+
+    // 5. Repositories
+    const postRepo = new PostRepository(this.db);
+    const engagementRepo = new EngagementRepository(this.db);
+    const campaignRepo = new CampaignRepository(this.db);
+    const strategyRepo = new StrategyRepository(this.db);
+    const ruleRepo = new RuleRepository(this.db);
+    const templateRepo = new TemplateRepository(this.db);
+    const audienceRepo = new AudienceRepository(this.db);
+    const synapseRepo = new SynapseRepository(this.db);
+    const insightRepo = new InsightRepository(this.db);
+
+    // 6. Synapse Manager
+    const synapseManager = new SynapseManager(synapseRepo, config.synapses);
+
+    // 7. Services
+    const services: Services = {
+      post: new PostService(postRepo, engagementRepo, synapseManager),
+      campaign: new CampaignService(campaignRepo, postRepo, engagementRepo, synapseManager),
+      strategy: new StrategyService(strategyRepo, synapseManager),
+      template: new TemplateService(templateRepo, synapseManager),
+      rule: new RuleService(ruleRepo, synapseManager),
+      audience: new AudienceService(audienceRepo, synapseManager),
+      synapse: new SynapseService(synapseManager),
+      analytics: new AnalyticsService(
+        postRepo, engagementRepo, campaignRepo,
+        strategyRepo, ruleRepo, templateRepo,
+        insightRepo, synapseManager,
+      ),
+      insight: new InsightService(insightRepo, synapseManager),
+    };
+
+    // 8. Learning Engine
+    this.learningEngine = new LearningEngine(
+      config.learning, postRepo, engagementRepo,
+      ruleRepo, strategyRepo, synapseManager,
+    );
+    this.learningEngine.start();
+    logger.info(`Learning engine started (interval: ${config.learning.intervalMs}ms)`);
+
+    // 9. Research Engine
+    this.researchEngine = new ResearchEngine(
+      config.research, postRepo, engagementRepo,
+      campaignRepo, templateRepo, insightRepo, synapseManager,
+    );
+    this.researchEngine.start();
+    logger.info(`Research engine started (interval: ${config.research.intervalMs}ms)`);
+
+    // Expose learning engine to IPC
+    services.learning = this.learningEngine;
+
+    // 10. IPC Server
+    const router = new IpcRouter(services);
+    this.ipcServer = new IpcServer(router, config.ipc.pipeName);
+    this.ipcServer.start();
+
+    // 11. REST API Server
+    if (config.api.enabled) {
+      this.apiServer = new ApiServer({
+        port: config.api.port,
+        router,
+        apiKey: config.api.apiKey,
+      });
+      this.apiServer.start();
+      logger.info(`REST API enabled on port ${config.api.port}`);
+    }
+
+    // 12. Dashboard Server (SSE)
+    if (config.dashboard.enabled) {
+      const dashboardHtmlPath = path.resolve(
+        path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1')),
+        '../dashboard.html',
+      );
+      const dashServices = {
+        analytics: services.analytics,
+        insight: services.insight,
+        rule: services.rule,
+        synapse: services.synapse,
+      };
+      this.dashboardServer = new DashboardServer({
+        port: config.dashboard.port,
+        getDashboardHtml: () => {
+          try {
+            const template = fs.readFileSync(dashboardHtmlPath, 'utf-8');
+            return renderDashboard(template, dashServices);
+          } catch {
+            return '<html><body><h1>Dashboard HTML not found</h1></body></html>';
+          }
+        },
+        getStats: () => services.analytics.getSummary(),
+      });
+      this.dashboardServer.start();
+      logger.info(`Dashboard server enabled on port ${config.dashboard.port}`);
+    }
+
+    // 13. Event listeners (synapse wiring)
+    this.setupEventListeners(synapseManager);
+
+    // 14. PID file
+    const pidPath = path.join(path.dirname(config.dbPath), 'marketing-brain.pid');
+    fs.writeFileSync(pidPath, String(process.pid));
+
+    // 15. Graceful shutdown
+    process.on('SIGINT', () => this.stop());
+    process.on('SIGTERM', () => this.stop());
+
+    // 16. Crash recovery — auto-restart on uncaught errors
+    process.on('uncaughtException', (err) => {
+      logger.error('Uncaught exception — restarting', { error: err.message, stack: err.stack });
+      this.logCrash('uncaughtException', err);
+      this.restart();
+    });
+    process.on('unhandledRejection', (reason) => {
+      logger.error('Unhandled rejection — restarting', { reason: String(reason) });
+      this.logCrash('unhandledRejection', reason instanceof Error ? reason : new Error(String(reason)));
+      this.restart();
+    });
+
+    logger.info(`Marketing Brain daemon started (PID: ${process.pid})`);
+  }
+
+  private logCrash(type: string, err: Error): void {
+    if (!this.config) return;
+    const crashLog = path.join(path.dirname(this.config.dbPath), 'crashes.log');
+    const entry = `[${new Date().toISOString()}] ${type}: ${err.message}\n${err.stack ?? ''}\n\n`;
+    try { fs.appendFileSync(crashLog, entry); } catch { /* best effort */ }
+  }
+
+  private cleanup(): void {
+    this.researchEngine?.stop();
+    this.learningEngine?.stop();
+    this.dashboardServer?.stop();
+    this.apiServer?.stop();
+    this.ipcServer?.stop();
+    this.db?.close();
+
+    this.db = null;
+    this.ipcServer = null;
+    this.apiServer = null;
+    this.dashboardServer = null;
+    this.learningEngine = null;
+    this.researchEngine = null;
+  }
+
+  restart(): void {
+    if (this.restarting) return;
+    this.restarting = true;
+
+    const logger = getLogger();
+    logger.info('Restarting Marketing Brain daemon...');
+
+    try { this.cleanup(); } catch { /* best effort cleanup */ }
+
+    this.restarting = false;
+    this.start(this.configPath);
+  }
+
+  stop(): void {
+    const logger = getLogger();
+    logger.info('Shutting down...');
+
+    this.cleanup();
+
+    if (this.config) {
+      const pidPath = path.join(path.dirname(this.config.dbPath), 'marketing-brain.pid');
+      try { fs.unlinkSync(pidPath); } catch { /* ignore */ }
+    }
+
+    logger.info('Marketing Brain daemon stopped');
+    process.exit(0);
+  }
+
+  private setupEventListeners(synapseManager: SynapseManager): void {
+    const bus = getEventBus();
+
+    bus.on('post:created', ({ postId, campaignId }) => {
+      if (campaignId) {
+        synapseManager.strengthen(
+          { type: 'post', id: postId },
+          { type: 'campaign', id: campaignId },
+          'belongs_to',
+        );
+      }
+    });
+
+    bus.on('strategy:reported', ({ strategyId, postId }) => {
+      synapseManager.strengthen(
+        { type: 'strategy', id: strategyId },
+        { type: 'post', id: postId },
+        'improves',
+      );
+    });
+
+    bus.on('rule:learned', ({ ruleId, pattern }) => {
+      getLogger().info(`New rule #${ruleId} learned: ${pattern}`);
+    });
+
+    bus.on('insight:created', ({ insightId, type }) => {
+      getLogger().info(`New insight #${insightId} (${type})`);
+    });
+  }
+}

package/src/mcp/server.ts

@@ -0,0 +1,72 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { IpcClient } from '../ipc/client.js';
+import { getPipeName } from '../utils/paths.js';
+import { registerTools } from './tools.js';
+
+function spawnDaemon(): void {
+  const entryPoint = path.resolve(import.meta.dirname, '../index.ts');
+  const child = spawn(process.execPath, [
+    '--import', 'tsx',
+    entryPoint, 'daemon',
+  ], {
+    detached: true,
+    stdio: 'ignore',
+    cwd: path.resolve(import.meta.dirname, '../..'),
+  });
+  child.unref();
+  process.stderr.write(`Marketing Brain: Auto-started daemon (PID: ${child.pid})\n`);
+}
+
+async function connectWithRetry(ipc: IpcClient, retries: number, delayMs: number): Promise<void> {
+  for (let i = 0; i < retries; i++) {
+    try {
+      await ipc.connect();
+      return;
+    } catch {
+      if (i < retries - 1) {
+        await new Promise(r => setTimeout(r, delayMs));
+      }
+    }
+  }
+  throw new Error('Could not connect to daemon after retries');
+}
+
+export async function startMcpServer(): Promise<void> {
+  const server = new McpServer({
+    name: 'marketing-brain',
+    version: '0.1.0',
+  });
+
+  const ipc = new IpcClient(getPipeName());
+
+  try {
+    await ipc.connect();
+  } catch {
+    process.stderr.write('Marketing Brain: Daemon not running, starting automatically...\n');
+    spawnDaemon();
+    try {
+      await connectWithRetry(ipc, 10, 500);
+    } catch {
+      process.stderr.write('Marketing Brain: Could not connect to daemon after auto-start.\n');
+      process.exit(1);
+    }
+  }
+
+  registerTools(server, ipc);
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  process.on('SIGINT', () => {
+    ipc.disconnect();
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', () => {
+    ipc.disconnect();
+    process.exit(0);
+  });
+}

package/src/mcp/tools.ts

@@ -0,0 +1,216 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { IpcClient } from '../ipc/client.js';
+
+export function registerTools(server: McpServer, ipc: IpcClient): void {
+
+  // 1. post.draft — Check a post draft against rules
+  server.tool(
+    'marketing_post_draft',
+    'Check a post draft against learned marketing rules before publishing. Returns violations and recommendations.',
+    {
+      content: z.string().describe('The post content/text to check'),
+      platform: z.string().describe('Target platform (x, reddit, linkedin, bluesky)'),
+    },
+    async ({ content, platform }) => {
+      const result = await ipc.request('rule.check', { content, platform });
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 2. post.report — Report a published post
+  server.tool(
+    'marketing_post_report',
+    'Report a published post to track in the marketing brain. Stores content, platform, format, and creates synapse connections.',
+    {
+      platform: z.string().describe('Platform (x, reddit, linkedin, bluesky)'),
+      content: z.string().describe('Post content/text'),
+      format: z.string().optional().describe('Post format (text, image, video, thread, article)'),
+      url: z.string().optional().describe('Post URL'),
+      hashtags: z.string().optional().describe('Hashtags (comma-separated)'),
+      campaign: z.string().optional().describe('Campaign name (creates if not exists)'),
+    },
+    async ({ platform, content, format, url, hashtags, campaign }) => {
+      let campaignId: number | null = null;
+      if (campaign) {
+        const camp = await ipc.request('campaign.create', { name: campaign }) as { id: number };
+        campaignId = camp.id;
+      }
+      const result = await ipc.request('post.report', {
+        platform, content, format: format ?? 'text',
+        url, hashtags, campaign_id: campaignId,
+        status: 'published', published_at: new Date().toISOString(),
+      });
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 3. post.engagement — Update engagement metrics
+  server.tool(
+    'marketing_post_engagement',
+    'Update engagement metrics for a tracked post. Provide post ID and current metrics.',
+    {
+      post_id: z.number().describe('Post ID'),
+      likes: z.number().optional().describe('Current likes count'),
+      comments: z.number().optional().describe('Current comments count'),
+      shares: z.number().optional().describe('Current shares/retweets count'),
+      impressions: z.number().optional().describe('Current impressions count'),
+      clicks: z.number().optional().describe('Current clicks count'),
+      saves: z.number().optional().describe('Current saves/bookmarks count'),
+      reach: z.number().optional().describe('Current reach count'),
+    },
+    async (params) => {
+      const result = await ipc.request('post.engagement', params);
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 4. post.similar — Find similar posts
+  server.tool(
+    'marketing_post_similar',
+    'Find posts similar to a given post using synapse network spreading activation.',
+    {
+      post_id: z.number().describe('Post ID to find similar posts for'),
+    },
+    async ({ post_id }) => {
+      const result = await ipc.request('post.similar', { id: post_id });
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 5. campaign.create — Create a new campaign
+  server.tool(
+    'marketing_campaign_create',
+    'Create a new marketing campaign to group and track related posts.',
+    {
+      name: z.string().describe('Campaign name'),
+      brand: z.string().optional().describe('Brand name (e.g., REPOSIGNAL, Brain)'),
+      goal: z.string().optional().describe('Campaign goal'),
+      platform: z.string().optional().describe('Primary platform'),
+    },
+    async (params) => {
+      const result = await ipc.request('campaign.create', params);
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 6. campaign.stats — Campaign performance
+  server.tool(
+    'marketing_campaign_stats',
+    'Get performance statistics for a campaign including total engagement and post count.',
+    {
+      campaign_id: z.number().describe('Campaign ID'),
+    },
+    async ({ campaign_id }) => {
+      const result = await ipc.request('campaign.stats', { id: campaign_id });
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 7. strategy.report — Report a successful strategy
+  server.tool(
+    'marketing_strategy_report',
+    'Report a marketing strategy that worked. The brain will learn from it and suggest similar strategies later.',
+    {
+      description: z.string().describe('Strategy description'),
+      approach: z.string().optional().describe('Approach taken'),
+      outcome: z.string().optional().describe('Outcome/result'),
+      post_id: z.number().optional().describe('Related post ID'),
+    },
+    async (params) => {
+      const result = await ipc.request('strategy.report', params);
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 8. strategy.suggest — Get strategy suggestions
+  server.tool(
+    'marketing_strategy_suggest',
+    'Get strategy suggestions based on a topic or context. Searches past successful strategies.',
+    {
+      query: z.string().describe('Topic or context to search for'),
+      limit: z.number().optional().describe('Max results (default: 5)'),
+    },
+    async ({ query, limit }) => {
+      const result = await ipc.request('strategy.suggest', { query, limit: limit ?? 5 });
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 9. template.find — Find content templates
+  server.tool(
+    'marketing_template_find',
+    'Find reusable content templates that match a query or platform.',
+    {
+      query: z.string().optional().describe('Search query'),
+      platform: z.string().optional().describe('Filter by platform'),
+      limit: z.number().optional().describe('Max results'),
+    },
+    async ({ query, platform, limit }) => {
+      let result;
+      if (platform) {
+        result = await ipc.request('template.byPlatform', { platform, limit: limit ?? 10 });
+      } else {
+        result = await ipc.request('template.find', { query: query ?? '', limit: limit ?? 10 });
+      }
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 10. rule.check — Check draft against rules
+  server.tool(
+    'marketing_rule_check',
+    'Check a post draft against all learned marketing rules. Returns violations and recommendations.',
+    {
+      content: z.string().describe('Post content to check'),
+      platform: z.string().describe('Target platform'),
+    },
+    async ({ content, platform }) => {
+      const result = await ipc.request('rule.check', { content, platform });
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 11. insight.list — List current insights
+  server.tool(
+    'marketing_insight_list',
+    'Get current active marketing insights (trends, gaps, synergies, optimizations).',
+    {
+      type: z.string().optional().describe('Filter by type: trend, gap, synergy, template, optimization'),
+      limit: z.number().optional().describe('Max results'),
+    },
+    async ({ type, limit }) => {
+      let result;
+      if (type) {
+        result = await ipc.request('insight.byType', { type, limit: limit ?? 20 });
+      } else {
+        result = await ipc.request('insight.list', { limit: limit ?? 20 });
+      }
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 12. analytics.summary — Overall analytics
+  server.tool(
+    'marketing_analytics_summary',
+    'Get a complete analytics summary: posts, campaigns, strategies, rules, insights, and network stats.',
+    {},
+    async () => {
+      const result = await ipc.request('analytics.summary', {});
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+
+  // 13. analytics.bestOf — Top performing content
+  server.tool(
+    'marketing_analytics_best',
+    'Get top performing posts, best strategies, and platform-level engagement stats.',
+    {
+      limit: z.number().optional().describe('Max results per category'),
+    },
+    async ({ limit }) => {
+      const result = await ipc.request('analytics.top', { limit: limit ?? 10 });
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+    },
+  );
+}