@timmeck/marketing-brain 0.2.0 → 0.3.0

package/src/db/repositories/synapse.repository.ts

@@ -1,148 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { Statement } from 'better-sqlite3';
-import type { SynapseRecord } from '../../types/synapse.types.js';
-
-type SynapseCreate = Omit<SynapseRecord, 'id' | 'activation_count' | 'last_activated_at' | 'created_at' | 'updated_at'>;
-type SynapseUpdate = Partial<Omit<SynapseRecord, 'id' | 'created_at'>>;
-
-export class SynapseRepository {
-  private stmts: Record<string, Statement>;
-
-  constructor(private db: Database.Database) {
-    this.stmts = {
-      create: db.prepare(`
-        INSERT INTO synapses (source_type, source_id, target_type, target_id, synapse_type, weight, metadata)
-        VALUES (@source_type, @source_id, @target_type, @target_id, @synapse_type, @weight, @metadata)
-      `),
-      getById: db.prepare('SELECT * FROM synapses WHERE id = ?'),
-      delete: db.prepare('DELETE FROM synapses WHERE id = ?'),
-      getOutgoing: db.prepare(
-        'SELECT * FROM synapses WHERE source_type = ? AND source_id = ? ORDER BY weight DESC'
-      ),
-      getIncoming: db.prepare(
-        'SELECT * FROM synapses WHERE target_type = ? AND target_id = ? ORDER BY weight DESC'
-      ),
-      findConnected: db.prepare(`
-        SELECT * FROM synapses
-        WHERE (source_type = ? AND source_id = ?) OR (target_type = ? AND target_id = ?)
-        ORDER BY weight DESC
-      `),
-      findBySourceTarget: db.prepare(`
-        SELECT * FROM synapses
-        WHERE source_type = ? AND source_id = ? AND target_type = ? AND target_id = ? AND synapse_type = ?
-      `),
-      findInactiveSince: db.prepare(`
-        SELECT * FROM synapses WHERE last_activated_at < ?
-      `),
-      countNodes: db.prepare(`
-        SELECT COUNT(*) as count FROM (
-          SELECT source_type, source_id FROM synapses
-          UNION
-          SELECT target_type, target_id FROM synapses
-        )
-      `),
-      avgWeight: db.prepare('SELECT AVG(weight) as avg_weight FROM synapses'),
-      countByType: db.prepare('SELECT synapse_type, COUNT(*) as count FROM synapses GROUP BY synapse_type'),
-      totalCount: db.prepare('SELECT COUNT(*) as count FROM synapses'),
-      topByWeight: db.prepare('SELECT * FROM synapses ORDER BY weight DESC LIMIT ?'),
-      topDiverse: db.prepare(`
-        SELECT * FROM (
-          SELECT *, ROW_NUMBER() OVER (PARTITION BY synapse_type ORDER BY weight DESC) as rn
-          FROM synapses
-        ) WHERE rn <= ? ORDER BY weight DESC
-      `),
-    };
-  }
-
-  create(data: SynapseCreate): number {
-    const result = this.stmts.create.run({
-      source_type: data.source_type,
-      source_id: data.source_id,
-      target_type: data.target_type,
-      target_id: data.target_id,
-      synapse_type: data.synapse_type,
-      weight: data.weight,
-      metadata: data.metadata ?? null,
-    });
-    return result.lastInsertRowid as number;
-  }
-
-  getById(id: number): SynapseRecord | undefined {
-    return this.stmts.getById.get(id) as SynapseRecord | undefined;
-  }
-
-  update(id: number, data: SynapseUpdate): boolean {
-    const fields = Object.keys(data).filter(
-      (key) => (data as Record<string, unknown>)[key] !== undefined
-    );
-    if (fields.length === 0) return false;
-
-    const setClauses = fields.map((field) => `${field} = @${field}`).join(', ');
-    const stmt = this.db.prepare(
-      `UPDATE synapses SET ${setClauses}, updated_at = datetime('now') WHERE id = @id`
-    );
-    const result = stmt.run({ ...data, id });
-    return result.changes > 0;
-  }
-
-  delete(id: number): boolean {
-    const result = this.stmts.delete.run(id);
-    return result.changes > 0;
-  }
-
-  getOutgoing(sourceType: string, sourceId: number): SynapseRecord[] {
-    return this.stmts.getOutgoing.all(sourceType, sourceId) as SynapseRecord[];
-  }
-
-  getIncoming(targetType: string, targetId: number): SynapseRecord[] {
-    return this.stmts.getIncoming.all(targetType, targetId) as SynapseRecord[];
-  }
-
-  findBySourceTarget(
-    sourceType: string, sourceId: number,
-    targetType: string, targetId: number,
-    synapseType: string,
-  ): SynapseRecord | undefined {
-    return this.stmts.findBySourceTarget.get(
-      sourceType, sourceId, targetType, targetId, synapseType
-    ) as SynapseRecord | undefined;
-  }
-
-  findConnected(nodeType: string, nodeId: number): SynapseRecord[] {
-    return this.stmts.findConnected.all(nodeType, nodeId, nodeType, nodeId) as SynapseRecord[];
-  }
-
-  findInactiveSince(cutoff: string): SynapseRecord[] {
-    return this.stmts.findInactiveSince.all(cutoff) as SynapseRecord[];
-  }
-
-  topByWeight(limit: number): SynapseRecord[] {
-    return this.stmts.topByWeight.all(limit) as SynapseRecord[];
-  }
-
-  topDiverse(perType: number): SynapseRecord[] {
-    return this.stmts.topDiverse.all(perType) as SynapseRecord[];
-  }
-
-  countNodes(): number {
-    const row = this.stmts.countNodes.get() as { count: number };
-    return row.count;
-  }
-
-  totalCount(): number {
-    const row = this.stmts.totalCount.get() as { count: number };
-    return row.count;
-  }
-
-  avgWeight(): number {
-    const row = this.stmts.avgWeight.get() as { avg_weight: number | null };
-    return row.avg_weight ?? 0;
-  }
-
-  countByType(): Record<string, number> {
-    const rows = this.stmts.countByType.all() as Array<{ synapse_type: string; count: number }>;
-    const result: Record<string, number> = {};
-    for (const row of rows) result[row.synapse_type] = row.count;
-    return result;
-  }
-}

package/src/db/repositories/template.repository.ts

@@ -1,76 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { Statement } from 'better-sqlite3';
-import type { ContentTemplate, ContentTemplateCreate } from '../../types/post.types.js';
-
-export class TemplateRepository {
-  private stmts: Record<string, Statement>;
-
-  constructor(private db: Database.Database) {
-    this.stmts = {
-      create: db.prepare(`
-        INSERT INTO content_templates (name, structure, example, platform)
-        VALUES (@name, @structure, @example, @platform)
-      `),
-      getById: db.prepare('SELECT * FROM content_templates WHERE id = ?'),
-      listAll: db.prepare('SELECT * FROM content_templates ORDER BY avg_engagement DESC LIMIT ?'),
-      listByPlatform: db.prepare('SELECT * FROM content_templates WHERE platform = ? ORDER BY avg_engagement DESC LIMIT ?'),
-      countAll: db.prepare('SELECT COUNT(*) as count FROM content_templates'),
-      search: db.prepare(`
-        SELECT t.* FROM content_templates t
-        JOIN content_templates_fts f ON f.rowid = t.id
-        WHERE content_templates_fts MATCH ?
-        ORDER BY rank
-        LIMIT ?
-      `),
-      delete: db.prepare('DELETE FROM content_templates WHERE id = ?'),
-    };
-  }
-
-  create(data: ContentTemplateCreate): number {
-    const result = this.stmts.create.run({
-      name: data.name,
-      structure: data.structure,
-      example: data.example ?? null,
-      platform: data.platform ?? null,
-    });
-    return result.lastInsertRowid as number;
-  }
-
-  getById(id: number): ContentTemplate | undefined {
-    return this.stmts.getById.get(id) as ContentTemplate | undefined;
-  }
-
-  listAll(limit: number = 50): ContentTemplate[] {
-    return this.stmts.listAll.all(limit) as ContentTemplate[];
-  }
-
-  listByPlatform(platform: string, limit: number = 20): ContentTemplate[] {
-    return this.stmts.listByPlatform.all(platform, limit) as ContentTemplate[];
-  }
-
-  search(query: string, limit: number = 20): ContentTemplate[] {
-    return this.stmts.search.all(query, limit) as ContentTemplate[];
-  }
-
-  incrementUseCount(id: number): void {
-    this.db.prepare(
-      `UPDATE content_templates SET use_count = use_count + 1 WHERE id = ?`
-    ).run(id);
-  }
-
-  updateAvgEngagement(id: number, avgEngagement: number): void {
-    this.db.prepare(
-      `UPDATE content_templates SET avg_engagement = ? WHERE id = ?`
-    ).run(avgEngagement, id);
-  }
-
-  countAll(): number {
-    const row = this.stmts.countAll.get() as { count: number };
-    return row.count;
-  }
-
-  delete(id: number): boolean {
-    const result = this.stmts.delete.run(id);
-    return result.changes > 0;
-  }
-}

package/src/index.ts

@@ -1,69 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { startCommand } from './cli/commands/start.js';
-import { stopCommand } from './cli/commands/stop.js';
-import { statusCommand } from './cli/commands/status.js';
-import { doctorCommand } from './cli/commands/doctor.js';
-import { postCommand } from './cli/commands/post.js';
-import { campaignCommand } from './cli/commands/campaign.js';
-import { insightsCommand } from './cli/commands/insights.js';
-import { rulesCommand } from './cli/commands/rules.js';
-import { suggestCommand } from './cli/commands/suggest.js';
-import { dashboardCommand } from './cli/commands/dashboard.js';
-import { importCommand } from './cli/commands/import.js';
-import { exportCommand } from './cli/commands/export.js';
-import { learnCommand } from './cli/commands/learn.js';
-import { networkCommand } from './cli/commands/network.js';
-import { queryCommand } from './cli/commands/query.js';
-import { configCommand } from './cli/commands/config.js';
-import { checkForUpdate, getCurrentVersion } from './cli/update-check.js';
-
-const program = new Command();
-
-program
-  .name('marketing')
-  .description('Marketing Brain — Self-Learning Marketing Intelligence System')
-  .version(getCurrentVersion());
-
-program.addCommand(startCommand());
-program.addCommand(stopCommand());
-program.addCommand(statusCommand());
-program.addCommand(doctorCommand());
-program.addCommand(postCommand());
-program.addCommand(campaignCommand());
-program.addCommand(insightsCommand());
-program.addCommand(rulesCommand());
-program.addCommand(suggestCommand());
-program.addCommand(dashboardCommand());
-program.addCommand(importCommand());
-program.addCommand(exportCommand());
-program.addCommand(learnCommand());
-program.addCommand(networkCommand());
-program.addCommand(queryCommand());
-program.addCommand(configCommand());
-
-// Hidden: MCP server (called by Claude Code)
-program
-  .command('mcp-server')
-  .description('Start MCP server (stdio transport, used by Claude Code)')
-  .action(async () => {
-    const { startMcpServer } = await import('./mcp/server.js');
-    await startMcpServer();
-  });
-
-// Hidden: run daemon in foreground
-program
-  .command('daemon')
-  .description('Run daemon in foreground')
-  .option('-c, --config <path>', 'Config file path')
-  .action(async (opts) => {
-    const { MarketingCore } = await import('./marketing-core.js');
-    const core = new MarketingCore();
-    core.start(opts.config);
-  });
-
-program.parse();
-
-// Non-blocking update check after command finishes
-checkForUpdate();

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();
-      }],
-    ]);
-  }
-}