@timmeck/marketing-brain 0.2.1 → 0.3.0

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

@@ -1,87 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { Statement } from 'better-sqlite3';
-import type { MarketingRule, RuleCreate } from '../../types/post.types.js';
-
-export class RuleRepository {
-  private stmts: Record<string, Statement>;
-
-  constructor(private db: Database.Database) {
-    this.stmts = {
-      create: db.prepare(`
-        INSERT INTO marketing_rules (pattern, recommendation, confidence)
-        VALUES (@pattern, @recommendation, @confidence)
-      `),
-      getById: db.prepare('SELECT * FROM marketing_rules WHERE id = ?'),
-      listAll: db.prepare('SELECT * FROM marketing_rules ORDER BY confidence DESC'),
-      listActive: db.prepare(`SELECT * FROM marketing_rules WHERE active = 1 ORDER BY confidence DESC`),
-      countAll: db.prepare('SELECT COUNT(*) as count FROM marketing_rules'),
-      countActive: db.prepare(`SELECT COUNT(*) as count FROM marketing_rules WHERE active = 1`),
-      delete: db.prepare('DELETE FROM marketing_rules WHERE id = ?'),
-    };
-  }
-
-  create(data: RuleCreate): number {
-    const result = this.stmts.create.run({
-      pattern: data.pattern,
-      recommendation: data.recommendation,
-      confidence: data.confidence ?? 0.5,
-    });
-    return result.lastInsertRowid as number;
-  }
-
-  getById(id: number): MarketingRule | undefined {
-    return this.stmts.getById.get(id) as MarketingRule | undefined;
-  }
-
-  listAll(): MarketingRule[] {
-    return this.stmts.listAll.all() as MarketingRule[];
-  }
-
-  listActive(): MarketingRule[] {
-    return this.stmts.listActive.all() as MarketingRule[];
-  }
-
-  update(id: number, data: Partial<MarketingRule>): boolean {
-    const fields = Object.keys(data).filter(
-      (key) => key !== 'id' && key !== 'created_at' && (data as Record<string, unknown>)[key] !== undefined
-    );
-    if (fields.length === 0) return false;
-
-    const setClauses = fields.map((f) => `${f} = @${f}`).join(', ');
-    const stmt = this.db.prepare(
-      `UPDATE marketing_rules SET ${setClauses}, updated_at = datetime('now') WHERE id = @id`
-    );
-    const result = stmt.run({ ...data, id });
-    return result.changes > 0;
-  }
-
-  incrementTrigger(id: number, success: boolean): void {
-    const rule = this.getById(id);
-    if (!rule) return;
-    const data: Record<string, unknown> = {
-      trigger_count: rule.trigger_count + 1,
-      id,
-    };
-    if (success) data['success_count'] = rule.success_count + 1;
-
-    const stmt = this.db.prepare(
-      `UPDATE marketing_rules SET trigger_count = @trigger_count${success ? ', success_count = @success_count' : ''}, updated_at = datetime('now') WHERE id = @id`
-    );
-    stmt.run(data);
-  }
-
-  countAll(): number {
-    const row = this.stmts.countAll.get() as { count: number };
-    return row.count;
-  }
-
-  countActive(): number {
-    const row = this.stmts.countActive.get() as { count: number };
-    return row.count;
-  }
-
-  delete(id: number): boolean {
-    const result = this.stmts.delete.run(id);
-    return result.changes > 0;
-  }
-}

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

@@ -1,82 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { Statement } from 'better-sqlite3';
-import type { Strategy, StrategyCreate } from '../../types/post.types.js';
-
-export class StrategyRepository {
-  private stmts: Record<string, Statement>;
-
-  constructor(private db: Database.Database) {
-    this.stmts = {
-      create: db.prepare(`
-        INSERT INTO strategies (post_id, description, approach, outcome, confidence)
-        VALUES (@post_id, @description, @approach, @outcome, @confidence)
-      `),
-      getById: db.prepare('SELECT * FROM strategies WHERE id = ?'),
-      listAll: db.prepare('SELECT * FROM strategies ORDER BY confidence DESC LIMIT ?'),
-      listByPost: db.prepare('SELECT * FROM strategies WHERE post_id = ? ORDER BY confidence DESC'),
-      countAll: db.prepare('SELECT COUNT(*) as count FROM strategies'),
-      search: db.prepare(`
-        SELECT s.* FROM strategies s
-        JOIN strategies_fts f ON f.rowid = s.id
-        WHERE strategies_fts MATCH ?
-        ORDER BY rank
-        LIMIT ?
-      `),
-      topByConfidence: db.prepare('SELECT * FROM strategies WHERE confidence >= ? ORDER BY confidence DESC LIMIT ?'),
-      delete: db.prepare('DELETE FROM strategies WHERE id = ?'),
-    };
-  }
-
-  create(data: StrategyCreate): number {
-    const result = this.stmts.create.run({
-      post_id: data.post_id ?? null,
-      description: data.description,
-      approach: data.approach ?? null,
-      outcome: data.outcome ?? null,
-      confidence: 0.5,
-    });
-    return result.lastInsertRowid as number;
-  }
-
-  getById(id: number): Strategy | undefined {
-    return this.stmts.getById.get(id) as Strategy | undefined;
-  }
-
-  listAll(limit: number = 50): Strategy[] {
-    return this.stmts.listAll.all(limit) as Strategy[];
-  }
-
-  listByPost(postId: number): Strategy[] {
-    return this.stmts.listByPost.all(postId) as Strategy[];
-  }
-
-  search(query: string, limit: number = 20): Strategy[] {
-    return this.stmts.search.all(query, limit) as Strategy[];
-  }
-
-  topByConfidence(minConfidence: number = 0.7, limit: number = 20): Strategy[] {
-    return this.stmts.topByConfidence.all(minConfidence, limit) as Strategy[];
-  }
-
-  update(id: number, data: Partial<Strategy>): boolean {
-    const fields = Object.keys(data).filter(
-      (key) => key !== 'id' && key !== 'created_at' && (data as Record<string, unknown>)[key] !== undefined
-    );
-    if (fields.length === 0) return false;
-
-    const setClauses = fields.map((f) => `${f} = @${f}`).join(', ');
-    const stmt = this.db.prepare(`UPDATE strategies SET ${setClauses} WHERE id = @id`);
-    const result = stmt.run({ ...data, id });
-    return result.changes > 0;
-  }
-
-  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/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/__tests__/protocol.test.ts

@@ -1,153 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Buffer } from 'node:buffer';
-import { encodeMessage, MessageDecoder } from '../protocol.js';
-import type { IpcMessage } from '../../types/ipc.types.js';
-
-const makeMessage = (overrides: Partial<IpcMessage> = {}): IpcMessage => ({
-  id: '1',
-  type: 'request',
-  method: 'ping',
-  ...overrides,
-});
-
-describe('encodeMessage', () => {
-  it('returns a Buffer', () => {
-    const buf = encodeMessage(makeMessage());
-    expect(Buffer.isBuffer(buf)).toBe(true);
-  });
-
-  it('prefixes payload with 4-byte big-endian length', () => {
-    const msg = makeMessage();
-    const buf = encodeMessage(msg);
-    const payloadLength = buf.readUInt32BE(0);
-    expect(buf.length).toBe(4 + payloadLength);
-  });
-
-  it('contains the JSON payload after the length prefix', () => {
-    const msg = makeMessage({ id: 'test-42', method: 'hello' });
-    const buf = encodeMessage(msg);
-    const payloadLength = buf.readUInt32BE(0);
-    const json = buf.subarray(4, 4 + payloadLength).toString('utf8');
-    const parsed = JSON.parse(json);
-    expect(parsed.id).toBe('test-42');
-    expect(parsed.method).toBe('hello');
-    expect(parsed.type).toBe('request');
-  });
-});
-
-describe('MessageDecoder', () => {
-  it('decodes a single complete message', () => {
-    const decoder = new MessageDecoder();
-    const msg = makeMessage({ id: 'a' });
-    const encoded = encodeMessage(msg);
-
-    const messages = decoder.feed(encoded);
-    expect(messages).toHaveLength(1);
-    expect(messages[0].id).toBe('a');
-  });
-
-  it('decodes multiple messages fed at once', () => {
-    const decoder = new MessageDecoder();
-    const buf = Buffer.concat([
-      encodeMessage(makeMessage({ id: '1' })),
-      encodeMessage(makeMessage({ id: '2' })),
-      encodeMessage(makeMessage({ id: '3' })),
-    ]);
-
-    const messages = decoder.feed(buf);
-    expect(messages).toHaveLength(3);
-    expect(messages.map((m) => m.id)).toEqual(['1', '2', '3']);
-  });
-
-  it('handles partial messages across multiple feeds', () => {
-    const decoder = new MessageDecoder();
-    const encoded = encodeMessage(makeMessage({ id: 'split' }));
-
-    // Split in the middle of the payload
-    const mid = Math.floor(encoded.length / 2);
-    const part1 = encoded.subarray(0, mid);
-    const part2 = encoded.subarray(mid);
-
-    const first = decoder.feed(part1);
-    expect(first).toHaveLength(0);
-
-    const second = decoder.feed(part2);
-    expect(second).toHaveLength(1);
-    expect(second[0].id).toBe('split');
-  });
-
-  it('handles chunk split inside the 4-byte length header', () => {
-    const decoder = new MessageDecoder();
-    const encoded = encodeMessage(makeMessage({ id: 'header-split' }));
-
-    // Only send 2 bytes of the 4-byte header
-    const first = decoder.feed(encoded.subarray(0, 2));
-    expect(first).toHaveLength(0);
-
-    const second = decoder.feed(encoded.subarray(2));
-    expect(second).toHaveLength(1);
-    expect(second[0].id).toBe('header-split');
-  });
-
-  it('returns empty array when buffer has incomplete data', () => {
-    const decoder = new MessageDecoder();
-    // Just 3 bytes -- not even enough for the length header
-    const partial = Buffer.from([0x00, 0x00, 0x00]);
-    expect(decoder.feed(partial)).toHaveLength(0);
-  });
-
-  it('reset clears internal buffer', () => {
-    const decoder = new MessageDecoder();
-    const encoded = encodeMessage(makeMessage({ id: 'before-reset' }));
-
-    // Feed partial data, then reset
-    decoder.feed(encoded.subarray(0, 5));
-    decoder.reset();
-
-    // Now feed a fresh complete message
-    const messages = decoder.feed(encodeMessage(makeMessage({ id: 'after-reset' })));
-    expect(messages).toHaveLength(1);
-    expect(messages[0].id).toBe('after-reset');
-  });
-
-  it('preserves leftover bytes for next feed', () => {
-    const decoder = new MessageDecoder();
-    const msg1 = encodeMessage(makeMessage({ id: 'first' }));
-    const msg2 = encodeMessage(makeMessage({ id: 'second' }));
-
-    // Feed first message + partial second message
-    const combined = Buffer.concat([msg1, msg2.subarray(0, 6)]);
-    const first = decoder.feed(combined);
-    expect(first).toHaveLength(1);
-    expect(first[0].id).toBe('first');
-
-    // Feed rest of second message
-    const second = decoder.feed(msg2.subarray(6));
-    expect(second).toHaveLength(1);
-    expect(second[0].id).toBe('second');
-  });
-
-  it('round-trips all IpcMessage fields', () => {
-    const decoder = new MessageDecoder();
-    const msg: IpcMessage = {
-      id: 'rt-1',
-      type: 'response',
-      result: { status: 'ok', data: [1, 2, 3] },
-    };
-    const messages = decoder.feed(encodeMessage(msg));
-    expect(messages).toHaveLength(1);
-    expect(messages[0]).toEqual(msg);
-  });
-
-  it('round-trips error messages', () => {
-    const decoder = new MessageDecoder();
-    const msg: IpcMessage = {
-      id: 'err-1',
-      type: 'response',
-      error: { code: -1, message: 'something went wrong' },
-    };
-    const messages = decoder.feed(encodeMessage(msg));
-    expect(messages).toHaveLength(1);
-    expect(messages[0]).toEqual(msg);
-  });
-});