@timmeck/marketing-brain 0.2.1 → 0.4.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);
-  });
-});

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);
-  }
-}