@timmeck/marketing-brain 0.2.0

package/src/db/migrations/001_core_schema.ts

@@ -0,0 +1,63 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS campaigns (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      brand TEXT,
+      goal TEXT,
+      platform TEXT,
+      status TEXT NOT NULL DEFAULT 'active',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS posts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      campaign_id INTEGER,
+      platform TEXT NOT NULL,
+      content TEXT NOT NULL,
+      format TEXT NOT NULL DEFAULT 'text',
+      hashtags TEXT,
+      url TEXT,
+      published_at TEXT,
+      fingerprint TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'draft',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (campaign_id) REFERENCES campaigns(id) ON DELETE SET NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS engagement (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      post_id INTEGER NOT NULL,
+      timestamp TEXT NOT NULL DEFAULT (datetime('now')),
+      likes INTEGER NOT NULL DEFAULT 0,
+      comments INTEGER NOT NULL DEFAULT 0,
+      shares INTEGER NOT NULL DEFAULT 0,
+      impressions INTEGER NOT NULL DEFAULT 0,
+      clicks INTEGER NOT NULL DEFAULT 0,
+      saves INTEGER NOT NULL DEFAULT 0,
+      reach INTEGER NOT NULL DEFAULT 0,
+      FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS audiences (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      platform TEXT,
+      demographics TEXT,
+      interests TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_posts_campaign ON posts(campaign_id);
+    CREATE INDEX IF NOT EXISTS idx_posts_platform ON posts(platform);
+    CREATE INDEX IF NOT EXISTS idx_posts_fingerprint ON posts(fingerprint);
+    CREATE INDEX IF NOT EXISTS idx_posts_status ON posts(status);
+    CREATE INDEX IF NOT EXISTS idx_posts_published ON posts(published_at);
+    CREATE INDEX IF NOT EXISTS idx_engagement_post ON engagement(post_id);
+    CREATE INDEX IF NOT EXISTS idx_engagement_timestamp ON engagement(timestamp);
+  `);
+}

package/src/db/migrations/002_learning_schema.ts

@@ -0,0 +1,46 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS strategies (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      post_id INTEGER,
+      description TEXT NOT NULL,
+      approach TEXT,
+      outcome TEXT,
+      confidence REAL NOT NULL DEFAULT 0.5,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE SET NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS marketing_rules (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      pattern TEXT NOT NULL,
+      recommendation TEXT NOT NULL,
+      confidence REAL NOT NULL DEFAULT 0.5,
+      trigger_count INTEGER NOT NULL DEFAULT 0,
+      success_count INTEGER NOT NULL DEFAULT 0,
+      active INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS content_templates (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      structure TEXT NOT NULL,
+      example TEXT,
+      platform TEXT,
+      avg_engagement REAL NOT NULL DEFAULT 0,
+      use_count INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_strategies_post ON strategies(post_id);
+    CREATE INDEX IF NOT EXISTS idx_strategies_confidence ON strategies(confidence);
+    CREATE INDEX IF NOT EXISTS idx_rules_active ON marketing_rules(active);
+    CREATE INDEX IF NOT EXISTS idx_rules_confidence ON marketing_rules(confidence);
+    CREATE INDEX IF NOT EXISTS idx_templates_platform ON content_templates(platform);
+    CREATE INDEX IF NOT EXISTS idx_templates_engagement ON content_templates(avg_engagement);
+  `);
+}

package/src/db/migrations/003_synapse_schema.ts

@@ -0,0 +1,27 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS synapses (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_type TEXT NOT NULL,
+      source_id INTEGER NOT NULL,
+      target_type TEXT NOT NULL,
+      target_id INTEGER NOT NULL,
+      synapse_type TEXT NOT NULL,
+      weight REAL NOT NULL DEFAULT 0.5,
+      activation_count INTEGER NOT NULL DEFAULT 1,
+      last_activated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      metadata TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(source_type, source_id, target_type, target_id, synapse_type)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_synapses_source ON synapses(source_type, source_id);
+    CREATE INDEX IF NOT EXISTS idx_synapses_target ON synapses(target_type, target_id);
+    CREATE INDEX IF NOT EXISTS idx_synapses_type ON synapses(synapse_type);
+    CREATE INDEX IF NOT EXISTS idx_synapses_weight ON synapses(weight);
+    CREATE INDEX IF NOT EXISTS idx_synapses_last_activated ON synapses(last_activated_at);
+  `);
+}

package/src/db/migrations/004_insights_schema.ts

@@ -0,0 +1,38 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS insights (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL,
+      confidence REAL NOT NULL DEFAULT 0.5,
+      priority INTEGER NOT NULL DEFAULT 0,
+      campaign_id INTEGER,
+      active INTEGER NOT NULL DEFAULT 1,
+      expires_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (campaign_id) REFERENCES campaigns(id) ON DELETE SET NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS notifications (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL,
+      title TEXT NOT NULL,
+      message TEXT NOT NULL,
+      priority INTEGER NOT NULL DEFAULT 0,
+      campaign_id INTEGER,
+      acknowledged INTEGER NOT NULL DEFAULT 0,
+      acknowledged_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (campaign_id) REFERENCES campaigns(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_insights_type ON insights(type);
+    CREATE INDEX IF NOT EXISTS idx_insights_campaign ON insights(campaign_id);
+    CREATE INDEX IF NOT EXISTS idx_insights_active ON insights(active);
+    CREATE INDEX IF NOT EXISTS idx_insights_priority ON insights(priority);
+    CREATE INDEX IF NOT EXISTS idx_notifications_acknowledged ON notifications(acknowledged);
+  `);
+}

package/src/db/migrations/005_fts_indexes.ts

@@ -0,0 +1,77 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    -- Full-text search for posts
+    CREATE VIRTUAL TABLE IF NOT EXISTS posts_fts USING fts5(
+      content, hashtags, platform,
+      content='posts',
+      content_rowid='id'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS posts_ai AFTER INSERT ON posts BEGIN
+      INSERT INTO posts_fts(rowid, content, hashtags, platform)
+      VALUES (new.id, new.content, new.hashtags, new.platform);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS posts_ad AFTER DELETE ON posts BEGIN
+      INSERT INTO posts_fts(posts_fts, rowid, content, hashtags, platform)
+      VALUES ('delete', old.id, old.content, old.hashtags, old.platform);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS posts_au AFTER UPDATE ON posts BEGIN
+      INSERT INTO posts_fts(posts_fts, rowid, content, hashtags, platform)
+      VALUES ('delete', old.id, old.content, old.hashtags, old.platform);
+      INSERT INTO posts_fts(rowid, content, hashtags, platform)
+      VALUES (new.id, new.content, new.hashtags, new.platform);
+    END;
+
+    -- Full-text search for strategies
+    CREATE VIRTUAL TABLE IF NOT EXISTS strategies_fts USING fts5(
+      description, approach, outcome,
+      content='strategies',
+      content_rowid='id'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS strategies_ai AFTER INSERT ON strategies BEGIN
+      INSERT INTO strategies_fts(rowid, description, approach, outcome)
+      VALUES (new.id, new.description, new.approach, new.outcome);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS strategies_ad AFTER DELETE ON strategies BEGIN
+      INSERT INTO strategies_fts(strategies_fts, rowid, description, approach, outcome)
+      VALUES ('delete', old.id, old.description, old.approach, old.outcome);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS strategies_au AFTER UPDATE ON strategies BEGIN
+      INSERT INTO strategies_fts(strategies_fts, rowid, description, approach, outcome)
+      VALUES ('delete', old.id, old.description, old.approach, old.outcome);
+      INSERT INTO strategies_fts(rowid, description, approach, outcome)
+      VALUES (new.id, new.description, new.approach, new.outcome);
+    END;
+
+    -- Full-text search for content templates
+    CREATE VIRTUAL TABLE IF NOT EXISTS content_templates_fts USING fts5(
+      name, structure, example,
+      content='content_templates',
+      content_rowid='id'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS templates_ai AFTER INSERT ON content_templates BEGIN
+      INSERT INTO content_templates_fts(rowid, name, structure, example)
+      VALUES (new.id, new.name, new.structure, new.example);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS templates_ad AFTER DELETE ON content_templates BEGIN
+      INSERT INTO content_templates_fts(content_templates_fts, rowid, name, structure, example)
+      VALUES ('delete', old.id, old.name, old.structure, old.example);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS templates_au AFTER UPDATE ON content_templates BEGIN
+      INSERT INTO content_templates_fts(content_templates_fts, rowid, name, structure, example)
+      VALUES ('delete', old.id, old.name, old.structure, old.example);
+      INSERT INTO content_templates_fts(rowid, name, structure, example)
+      VALUES (new.id, new.name, new.structure, new.example);
+    END;
+  `);
+}

package/src/db/migrations/index.ts

@@ -0,0 +1,62 @@
+import type Database from 'better-sqlite3';
+import { getLogger } from '../../utils/logger.js';
+import { up as coreSchema } from './001_core_schema.js';
+import { up as learningSchema } from './002_learning_schema.js';
+import { up as synapseSchema } from './003_synapse_schema.js';
+import { up as insightsSchema } from './004_insights_schema.js';
+import { up as ftsIndexes } from './005_fts_indexes.js';
+
+interface Migration {
+  version: number;
+  name: string;
+  up: (db: Database.Database) => void;
+}
+
+const migrations: Migration[] = [
+  { version: 1, name: '001_core_schema', up: coreSchema },
+  { version: 2, name: '002_learning_schema', up: learningSchema },
+  { version: 3, name: '003_synapse_schema', up: synapseSchema },
+  { version: 4, name: '004_insights_schema', up: insightsSchema },
+  { version: 5, name: '005_fts_indexes', up: ftsIndexes },
+];
+
+function ensureMigrationsTable(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS migrations (
+      version INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}
+
+function getCurrentVersion(db: Database.Database): number {
+  const row = db.prepare('SELECT MAX(version) as version FROM migrations').get() as { version: number | null } | undefined;
+  return row?.version ?? 0;
+}
+
+export function runMigrations(db: Database.Database): void {
+  const logger = getLogger();
+  ensureMigrationsTable(db);
+
+  const currentVersion = getCurrentVersion(db);
+  const pending = migrations.filter(m => m.version > currentVersion);
+
+  if (pending.length === 0) {
+    logger.info('Database is up to date');
+    return;
+  }
+
+  logger.info(`Running ${pending.length} migration(s) from version ${currentVersion}`);
+
+  const runAll = db.transaction(() => {
+    for (const migration of pending) {
+      logger.info(`Applying migration ${migration.name}`);
+      migration.up(db);
+      db.prepare('INSERT INTO migrations (version, name) VALUES (?, ?)').run(migration.version, migration.name);
+    }
+  });
+
+  runAll();
+  logger.info(`Migrations complete. Now at version ${pending[pending.length - 1]!.version}`);
+}

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

@@ -0,0 +1,53 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { Audience } from '../../types/post.types.js';
+
+export class AudienceRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO audiences (name, platform, demographics, interests)
+        VALUES (@name, @platform, @demographics, @interests)
+      `),
+      getById: db.prepare('SELECT * FROM audiences WHERE id = ?'),
+      getByName: db.prepare('SELECT * FROM audiences WHERE name = ?'),
+      listAll: db.prepare('SELECT * FROM audiences ORDER BY created_at DESC'),
+      countAll: db.prepare('SELECT COUNT(*) as count FROM audiences'),
+      delete: db.prepare('DELETE FROM audiences WHERE id = ?'),
+    };
+  }
+
+  create(data: { name: string; platform?: string; demographics?: string; interests?: string }): number {
+    const result = this.stmts.create.run({
+      name: data.name,
+      platform: data.platform ?? null,
+      demographics: data.demographics ?? null,
+      interests: data.interests ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): Audience | undefined {
+    return this.stmts.getById.get(id) as Audience | undefined;
+  }
+
+  getByName(name: string): Audience | undefined {
+    return this.stmts.getByName.get(name) as Audience | undefined;
+  }
+
+  listAll(): Audience[] {
+    return this.stmts.listAll.all() as Audience[];
+  }
+
+  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/campaign.repository.ts

@@ -0,0 +1,72 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { Campaign, CampaignCreate } from '../../types/post.types.js';
+
+export class CampaignRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO campaigns (name, brand, goal, platform)
+        VALUES (@name, @brand, @goal, @platform)
+      `),
+      getById: db.prepare('SELECT * FROM campaigns WHERE id = ?'),
+      getByName: db.prepare('SELECT * FROM campaigns WHERE name = ?'),
+      listAll: db.prepare('SELECT * FROM campaigns ORDER BY created_at DESC'),
+      listActive: db.prepare(`SELECT * FROM campaigns WHERE status = 'active' ORDER BY created_at DESC`),
+      countAll: db.prepare('SELECT COUNT(*) as count FROM campaigns'),
+      delete: db.prepare('DELETE FROM campaigns WHERE id = ?'),
+    };
+  }
+
+  create(data: CampaignCreate): number {
+    const result = this.stmts.create.run({
+      name: data.name,
+      brand: data.brand ?? null,
+      goal: data.goal ?? null,
+      platform: data.platform ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): Campaign | undefined {
+    return this.stmts.getById.get(id) as Campaign | undefined;
+  }
+
+  getByName(name: string): Campaign | undefined {
+    return this.stmts.getByName.get(name) as Campaign | undefined;
+  }
+
+  listAll(): Campaign[] {
+    return this.stmts.listAll.all() as Campaign[];
+  }
+
+  listActive(): Campaign[] {
+    return this.stmts.listActive.all() as Campaign[];
+  }
+
+  update(id: number, data: Partial<Campaign>): 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 campaigns SET ${setClauses}, updated_at = datetime('now') 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/engagement.repository.ts

@@ -0,0 +1,108 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { Engagement, EngagementCreate } from '../../types/post.types.js';
+
+export class EngagementRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO engagement (post_id, likes, comments, shares, impressions, clicks, saves, reach)
+        VALUES (@post_id, @likes, @comments, @shares, @impressions, @clicks, @saves, @reach)
+      `),
+      getById: db.prepare('SELECT * FROM engagement WHERE id = ?'),
+      getByPost: db.prepare('SELECT * FROM engagement WHERE post_id = ? ORDER BY timestamp DESC LIMIT 1'),
+      listByPost: db.prepare('SELECT * FROM engagement WHERE post_id = ? ORDER BY timestamp DESC'),
+      getLatestPerPost: db.prepare(`
+        SELECT e.* FROM engagement e
+        INNER JOIN (
+          SELECT post_id, MAX(timestamp) as max_ts FROM engagement GROUP BY post_id
+        ) latest ON e.post_id = latest.post_id AND e.timestamp = latest.max_ts
+        ORDER BY (e.likes + e.comments + e.shares + e.impressions) DESC
+        LIMIT ?
+      `),
+      topPosts: db.prepare(`
+        SELECT e.*, p.platform, p.content, p.published_at FROM engagement e
+        INNER JOIN posts p ON p.id = e.post_id
+        INNER JOIN (
+          SELECT post_id, MAX(timestamp) as max_ts FROM engagement GROUP BY post_id
+        ) latest ON e.post_id = latest.post_id AND e.timestamp = latest.max_ts
+        WHERE p.status = 'published'
+        ORDER BY (e.likes + e.comments * 3 + e.shares * 5 + e.clicks * 2) DESC
+        LIMIT ?
+      `),
+      avgByPlatform: db.prepare(`
+        SELECT p.platform,
+          AVG(e.likes) as avg_likes,
+          AVG(e.comments) as avg_comments,
+          AVG(e.shares) as avg_shares,
+          AVG(e.impressions) as avg_impressions,
+          AVG(e.clicks) as avg_clicks,
+          COUNT(DISTINCT e.post_id) as post_count
+        FROM engagement e
+        INNER JOIN posts p ON p.id = e.post_id
+        INNER JOIN (
+          SELECT post_id, MAX(timestamp) as max_ts FROM engagement GROUP BY post_id
+        ) latest ON e.post_id = latest.post_id AND e.timestamp = latest.max_ts
+        GROUP BY p.platform
+      `),
+      delete: db.prepare('DELETE FROM engagement WHERE id = ?'),
+    };
+  }
+
+  create(data: EngagementCreate): number {
+    const result = this.stmts.create.run({
+      post_id: data.post_id,
+      likes: data.likes ?? 0,
+      comments: data.comments ?? 0,
+      shares: data.shares ?? 0,
+      impressions: data.impressions ?? 0,
+      clicks: data.clicks ?? 0,
+      saves: data.saves ?? 0,
+      reach: data.reach ?? 0,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): Engagement | undefined {
+    return this.stmts.getById.get(id) as Engagement | undefined;
+  }
+
+  getLatestByPost(postId: number): Engagement | undefined {
+    return this.stmts.getByPost.get(postId) as Engagement | undefined;
+  }
+
+  listByPost(postId: number): Engagement[] {
+    return this.stmts.listByPost.all(postId) as Engagement[];
+  }
+
+  topPosts(limit: number = 10): Array<Engagement & { platform: string; content: string; published_at: string }> {
+    return this.stmts.topPosts.all(limit) as Array<Engagement & { platform: string; content: string; published_at: string }>;
+  }
+
+  avgByPlatform(): Array<{
+    platform: string;
+    avg_likes: number;
+    avg_comments: number;
+    avg_shares: number;
+    avg_impressions: number;
+    avg_clicks: number;
+    post_count: number;
+  }> {
+    return this.stmts.avgByPlatform.all() as Array<{
+      platform: string;
+      avg_likes: number;
+      avg_comments: number;
+      avg_shares: number;
+      avg_impressions: number;
+      avg_clicks: number;
+      post_count: number;
+    }>;
+  }
+
+  delete(id: number): boolean {
+    const result = this.stmts.delete.run(id);
+    return result.changes > 0;
+  }
+}

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

@@ -0,0 +1,100 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { Insight, InsightCreate } from '../../types/post.types.js';
+
+export class InsightRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO insights (type, title, description, confidence, priority, campaign_id, expires_at)
+        VALUES (@type, @title, @description, @confidence, @priority, @campaign_id, @expires_at)
+      `),
+      getById: db.prepare('SELECT * FROM insights WHERE id = ?'),
+      listActive: db.prepare(`
+        SELECT * FROM insights
+        WHERE active = 1 AND (expires_at IS NULL OR expires_at > datetime('now'))
+        ORDER BY priority DESC, confidence DESC
+        LIMIT ?
+      `),
+      listAll: db.prepare('SELECT * FROM insights ORDER BY created_at DESC LIMIT ?'),
+      listByType: db.prepare(`
+        SELECT * FROM insights WHERE type = ? AND active = 1
+        ORDER BY priority DESC LIMIT ?
+      `),
+      listByCampaign: db.prepare(`
+        SELECT * FROM insights WHERE campaign_id = ? AND active = 1
+        ORDER BY priority DESC
+      `),
+      countActive: db.prepare(`
+        SELECT COUNT(*) as count FROM insights
+        WHERE active = 1 AND (expires_at IS NULL OR expires_at > datetime('now'))
+      `),
+      countAll: db.prepare('SELECT COUNT(*) as count FROM insights'),
+      deactivate: db.prepare('UPDATE insights SET active = 0 WHERE id = ?'),
+      expireOld: db.prepare(`
+        UPDATE insights SET active = 0
+        WHERE active = 1 AND expires_at IS NOT NULL AND expires_at <= datetime('now')
+      `),
+      delete: db.prepare('DELETE FROM insights WHERE id = ?'),
+    };
+  }
+
+  create(data: InsightCreate): number {
+    const result = this.stmts.create.run({
+      type: data.type,
+      title: data.title,
+      description: data.description,
+      confidence: data.confidence ?? 0.5,
+      priority: data.priority ?? 0,
+      campaign_id: data.campaign_id ?? null,
+      expires_at: data.expires_at ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): Insight | undefined {
+    return this.stmts.getById.get(id) as Insight | undefined;
+  }
+
+  listActive(limit: number = 20): Insight[] {
+    return this.stmts.listActive.all(limit) as Insight[];
+  }
+
+  listAll(limit: number = 50): Insight[] {
+    return this.stmts.listAll.all(limit) as Insight[];
+  }
+
+  listByType(type: string, limit: number = 20): Insight[] {
+    return this.stmts.listByType.all(type, limit) as Insight[];
+  }
+
+  listByCampaign(campaignId: number): Insight[] {
+    return this.stmts.listByCampaign.all(campaignId) as Insight[];
+  }
+
+  deactivate(id: number): void {
+    this.stmts.deactivate.run(id);
+  }
+
+  expireOld(): number {
+    const result = this.stmts.expireOld.run();
+    return result.changes;
+  }
+
+  countActive(): number {
+    const row = this.stmts.countActive.get() as { count: number };
+    return row.count;
+  }
+
+  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;
+  }
+}