@timmeck/marketing-brain 0.2.0

package/src/services/strategy.service.ts

@@ -0,0 +1,53 @@
+import type { StrategyRepository } from '../db/repositories/strategy.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { Strategy, StrategyCreate } from '../types/post.types.js';
+import { getEventBus } from '../utils/events.js';
+
+export class StrategyService {
+  constructor(
+    private strategyRepo: StrategyRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  report(data: StrategyCreate): Strategy {
+    const id = this.strategyRepo.create(data);
+    const strategy = this.strategyRepo.getById(id)!;
+
+    if (data.post_id) {
+      this.synapseManager.strengthen(
+        { type: 'strategy', id },
+        { type: 'post', id: data.post_id },
+        'improves',
+      );
+      getEventBus().emit('strategy:reported', { strategyId: id, postId: data.post_id });
+    }
+
+    return strategy;
+  }
+
+  suggest(query: string, limit: number = 5): Strategy[] {
+    return this.strategyRepo.search(query, limit);
+  }
+
+  getTopStrategies(minConfidence: number = 0.7, limit: number = 10): Strategy[] {
+    return this.strategyRepo.topByConfidence(minConfidence, limit);
+  }
+
+  getById(id: number): Strategy | undefined {
+    return this.strategyRepo.getById(id);
+  }
+
+  listAll(limit?: number): Strategy[] {
+    return this.strategyRepo.listAll(limit);
+  }
+
+  updateConfidence(id: number, confidence: number): void {
+    this.strategyRepo.update(id, { confidence });
+  }
+
+  getStats() {
+    return {
+      total: this.strategyRepo.countAll(),
+    };
+  }
+}

package/src/services/synapse.service.ts

@@ -0,0 +1,32 @@
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { NodeType } from '../types/synapse.types.js';
+
+export class SynapseService {
+  constructor(private synapseManager: SynapseManager) {}
+
+  getPostContext(postId: number) {
+    return this.synapseManager.getPostContext(postId);
+  }
+
+  findPath(fromType: NodeType, fromId: number, toType: NodeType, toId: number) {
+    return this.synapseManager.findPath(
+      { type: fromType, id: fromId },
+      { type: toType, id: toId },
+    );
+  }
+
+  getRelated(opts: { nodeType: NodeType; nodeId: number; maxDepth?: number }) {
+    return this.synapseManager.activate(
+      { type: opts.nodeType, id: opts.nodeId },
+      opts.maxDepth,
+    );
+  }
+
+  getNetworkStats() {
+    return this.synapseManager.getNetworkStats();
+  }
+
+  getStrongest(limit?: number) {
+    return this.synapseManager.getStrongestSynapses(limit);
+  }
+}

package/src/services/template.service.ts

@@ -0,0 +1,50 @@
+import type { TemplateRepository } from '../db/repositories/template.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { ContentTemplate, ContentTemplateCreate } from '../types/post.types.js';
+import { getEventBus } from '../utils/events.js';
+
+export class TemplateService {
+  constructor(
+    private templateRepo: TemplateRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  create(data: ContentTemplateCreate): ContentTemplate {
+    const id = this.templateRepo.create(data);
+    const template = this.templateRepo.getById(id)!;
+
+    getEventBus().emit('template:created', { templateId: id, platform: data.platform ?? 'any' });
+    return template;
+  }
+
+  find(query: string, limit: number = 5): ContentTemplate[] {
+    return this.templateRepo.search(query, limit);
+  }
+
+  findByPlatform(platform: string, limit: number = 10): ContentTemplate[] {
+    return this.templateRepo.listByPlatform(platform, limit);
+  }
+
+  useTemplate(templateId: number, postId: number): void {
+    this.templateRepo.incrementUseCount(templateId);
+    this.synapseManager.strengthen(
+      { type: 'template', id: templateId },
+      { type: 'post', id: postId },
+      'generated_from',
+    );
+  }
+
+  getById(id: number): ContentTemplate | undefined {
+    return this.templateRepo.getById(id);
+  }
+
+  listAll(limit?: number): ContentTemplate[] {
+    return this.templateRepo.listAll(limit);
+  }
+
+  getStats() {
+    return {
+      total: this.templateRepo.countAll(),
+    };
+  }
+}

package/src/synapses/activation.ts

@@ -0,0 +1,80 @@
+import type { NodeType } from '../types/synapse.types.js';
+import type { SynapseRepository } from '../db/repositories/synapse.repository.js';
+
+export interface ActivationNode {
+  type: NodeType;
+  id: number;
+}
+
+export interface ActivationResult {
+  node: ActivationNode;
+  activation: number;
+  depth: number;
+  path: string[];
+}
+
+export function spreadingActivation(
+  repo: SynapseRepository,
+  startNode: ActivationNode,
+  maxDepth: number = 3,
+  minWeight: number = 0.2,
+): ActivationResult[] {
+  const visited = new Set<string>();
+  const results: ActivationResult[] = [];
+
+  const queue: Array<{
+    node: ActivationNode;
+    depth: number;
+    pathWeight: number;
+    path: string[];
+  }> = [{ node: startNode, depth: 0, pathWeight: 1.0, path: [] }];
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const key = `${current.node.type}:${current.node.id}`;
+
+    if (visited.has(key)) continue;
+    if (current.depth > maxDepth) continue;
+    if (current.pathWeight < minWeight) continue;
+
+    visited.add(key);
+
+    if (current.depth > 0) {
+      results.push({
+        node: current.node,
+        activation: current.pathWeight,
+        depth: current.depth,
+        path: current.path,
+      });
+    }
+
+    const outgoing = repo.getOutgoing(current.node.type, current.node.id);
+    const incoming = repo.getIncoming(current.node.type, current.node.id);
+
+    for (const synapse of outgoing) {
+      const nextWeight = current.pathWeight * synapse.weight;
+      if (nextWeight >= minWeight) {
+        queue.push({
+          node: { type: synapse.target_type, id: synapse.target_id },
+          depth: current.depth + 1,
+          pathWeight: nextWeight,
+          path: [...current.path, `--${synapse.synapse_type}-->`],
+        });
+      }
+    }
+
+    for (const synapse of incoming) {
+      const nextWeight = current.pathWeight * synapse.weight;
+      if (nextWeight >= minWeight) {
+        queue.push({
+          node: { type: synapse.source_type, id: synapse.source_id },
+          depth: current.depth + 1,
+          pathWeight: nextWeight,
+          path: [...current.path, `<--${synapse.synapse_type}--`],
+        });
+      }
+    }
+  }
+
+  return results.sort((a, b) => b.activation - a.activation);
+}

package/src/synapses/decay.ts

@@ -0,0 +1,38 @@
+import type { SynapseRepository } from '../db/repositories/synapse.repository.js';
+
+export interface DecayConfig {
+  decayHalfLifeDays: number;
+  decayAfterDays: number;
+  pruneThreshold: number;
+}
+
+export function timeDecayFactor(lastActivatedAt: string, halfLifeDays: number): number {
+  const now = Date.now();
+  const activated = new Date(lastActivatedAt).getTime();
+  const ageDays = (now - activated) / (1000 * 60 * 60 * 24);
+  return Math.pow(0.5, ageDays / halfLifeDays);
+}
+
+export function decayAll(repo: SynapseRepository, config: DecayConfig): { decayed: number; pruned: number } {
+  const cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - config.decayAfterDays);
+
+  const stale = repo.findInactiveSince(cutoff.toISOString());
+  let pruned = 0;
+  let decayed = 0;
+
+  for (const synapse of stale) {
+    const factor = timeDecayFactor(synapse.last_activated_at, config.decayHalfLifeDays);
+    const newWeight = synapse.weight * factor;
+
+    if (newWeight < config.pruneThreshold) {
+      repo.delete(synapse.id);
+      pruned++;
+    } else {
+      repo.update(synapse.id, { weight: newWeight });
+      decayed++;
+    }
+  }
+
+  return { decayed, pruned };
+}

package/src/synapses/hebbian.ts

@@ -0,0 +1,68 @@
+import type { SynapseRecord, NodeType, SynapseType } from '../types/synapse.types.js';
+import type { SynapseRepository } from '../db/repositories/synapse.repository.js';
+
+export interface HebbianConfig {
+  initialWeight: number;
+  learningRate: number;
+  pruneThreshold: number;
+}
+
+export interface NodeRef {
+  type: NodeType;
+  id: number;
+}
+
+export function strengthen(
+  repo: SynapseRepository,
+  source: NodeRef,
+  target: NodeRef,
+  synapseType: SynapseType,
+  config: HebbianConfig,
+  context?: Record<string, unknown>,
+): SynapseRecord {
+  const existing = repo.findBySourceTarget(
+    source.type, source.id, target.type, target.id, synapseType,
+  );
+
+  if (existing) {
+    const newWeight = Math.min(
+      1.0,
+      existing.weight + (1.0 - existing.weight) * config.learningRate,
+    );
+    repo.update(existing.id, {
+      weight: newWeight,
+      activation_count: existing.activation_count + 1,
+      last_activated_at: new Date().toISOString(),
+    });
+    return { ...existing, weight: newWeight, activation_count: existing.activation_count + 1 };
+  }
+
+  const id = repo.create({
+    source_type: source.type,
+    source_id: source.id,
+    target_type: target.type,
+    target_id: target.id,
+    synapse_type: synapseType,
+    weight: config.initialWeight,
+    metadata: context ? JSON.stringify(context) : null,
+  });
+
+  return repo.getById(id)!;
+}
+
+export function weaken(
+  repo: SynapseRepository,
+  synapseId: number,
+  config: HebbianConfig,
+  factor: number = 0.5,
+): void {
+  const synapse = repo.getById(synapseId);
+  if (!synapse) return;
+
+  const newWeight = synapse.weight * factor;
+  if (newWeight < config.pruneThreshold) {
+    repo.delete(synapseId);
+  } else {
+    repo.update(synapseId, { weight: newWeight });
+  }
+}

package/src/synapses/pathfinder.ts

@@ -0,0 +1,81 @@
+import type { NodeType, SynapseRecord } from '../types/synapse.types.js';
+import type { SynapseRepository } from '../db/repositories/synapse.repository.js';
+
+export interface PathNode {
+  type: NodeType;
+  id: number;
+}
+
+export interface SynapsePath {
+  from: PathNode;
+  to: PathNode;
+  synapses: SynapseRecord[];
+  totalWeight: number;
+  hops: number;
+}
+
+export function findPath(
+  repo: SynapseRepository,
+  from: PathNode,
+  to: PathNode,
+  maxDepth: number = 5,
+): SynapsePath | null {
+  const visited = new Set<string>();
+
+  const queue: Array<{
+    node: PathNode;
+    path: SynapseRecord[];
+    totalWeight: number;
+  }> = [{ node: from, path: [], totalWeight: 1.0 }];
+
+  let bestPath: SynapsePath | null = null;
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const key = `${current.node.type}:${current.node.id}`;
+
+    if (visited.has(key)) continue;
+    visited.add(key);
+
+    if (current.node.type === to.type && current.node.id === to.id) {
+      if (!bestPath || current.totalWeight > bestPath.totalWeight) {
+        bestPath = {
+          from,
+          to,
+          synapses: current.path,
+          totalWeight: current.totalWeight,
+          hops: current.path.length,
+        };
+      }
+      continue;
+    }
+
+    if (current.path.length >= maxDepth) continue;
+
+    const outgoing = repo.getOutgoing(current.node.type, current.node.id);
+    for (const synapse of outgoing) {
+      const targetKey = `${synapse.target_type}:${synapse.target_id}`;
+      if (!visited.has(targetKey)) {
+        queue.push({
+          node: { type: synapse.target_type, id: synapse.target_id },
+          path: [...current.path, synapse],
+          totalWeight: current.totalWeight * synapse.weight,
+        });
+      }
+    }
+
+    const incoming = repo.getIncoming(current.node.type, current.node.id);
+    for (const synapse of incoming) {
+      const sourceKey = `${synapse.source_type}:${synapse.source_id}`;
+      if (!visited.has(sourceKey)) {
+        queue.push({
+          node: { type: synapse.source_type, id: synapse.source_id },
+          path: [...current.path, synapse],
+          totalWeight: current.totalWeight * synapse.weight,
+        });
+      }
+    }
+  }
+
+  return bestPath;
+}

package/src/synapses/synapse-manager.ts

@@ -0,0 +1,115 @@
+import type { SynapsesConfig } from '../types/config.types.js';
+import type { NodeType, SynapseType, SynapseRecord, NetworkStats } from '../types/synapse.types.js';
+import type { SynapseRepository } from '../db/repositories/synapse.repository.js';
+import { strengthen, weaken, type NodeRef } from './hebbian.js';
+import { decayAll } from './decay.js';
+import { spreadingActivation, type ActivationResult } from './activation.js';
+import { findPath, type SynapsePath } from './pathfinder.js';
+import { getLogger } from '../utils/logger.js';
+
+export class SynapseManager {
+  private logger = getLogger();
+
+  constructor(
+    private repo: SynapseRepository,
+    private config: SynapsesConfig,
+  ) {}
+
+  strengthen(
+    source: NodeRef,
+    target: NodeRef,
+    synapseType: SynapseType,
+    context?: Record<string, unknown>,
+  ): SynapseRecord {
+    this.logger.debug(`Strengthening synapse ${source.type}:${source.id} --${synapseType}--> ${target.type}:${target.id}`);
+    return strengthen(this.repo, source, target, synapseType, {
+      initialWeight: this.config.initialWeight,
+      learningRate: this.config.learningRate,
+      pruneThreshold: this.config.pruneThreshold,
+    }, context);
+  }
+
+  weaken(synapseId: number, factor: number = 0.5): void {
+    this.logger.debug(`Weakening synapse ${synapseId} by factor ${factor}`);
+    weaken(this.repo, synapseId, {
+      initialWeight: this.config.initialWeight,
+      learningRate: this.config.learningRate,
+      pruneThreshold: this.config.pruneThreshold,
+    }, factor);
+  }
+
+  find(
+    source: NodeRef,
+    target: NodeRef,
+    synapseType: SynapseType,
+  ): SynapseRecord | undefined {
+    return this.repo.findBySourceTarget(
+      source.type, source.id, target.type, target.id, synapseType,
+    );
+  }
+
+  activate(
+    startNode: NodeRef,
+    maxDepth?: number,
+    minWeight?: number,
+  ): ActivationResult[] {
+    return spreadingActivation(
+      this.repo,
+      startNode,
+      maxDepth ?? this.config.maxDepth,
+      minWeight ?? this.config.minActivationWeight,
+    );
+  }
+
+  findPath(from: NodeRef, to: NodeRef, maxDepth?: number): SynapsePath | null {
+    return findPath(this.repo, from, to, maxDepth ?? this.config.maxDepth + 2);
+  }
+
+  runDecay(): { decayed: number; pruned: number } {
+    this.logger.info('Running synapse decay cycle');
+    const result = decayAll(this.repo, {
+      decayHalfLifeDays: this.config.decayHalfLifeDays,
+      decayAfterDays: this.config.decayAfterDays,
+      pruneThreshold: this.config.pruneThreshold,
+    });
+    this.logger.info(`Decay complete: ${result.decayed} decayed, ${result.pruned} pruned`);
+    return result;
+  }
+
+  getPostContext(postId: number): {
+    campaigns: ActivationResult[];
+    similarPosts: ActivationResult[];
+    strategies: ActivationResult[];
+    rules: ActivationResult[];
+    templates: ActivationResult[];
+    insights: ActivationResult[];
+  } {
+    const all = this.activate({ type: 'post', id: postId });
+    return {
+      campaigns: all.filter(a => a.node.type === 'campaign'),
+      similarPosts: all.filter(a => a.node.type === 'post'),
+      strategies: all.filter(a => a.node.type === 'strategy'),
+      rules: all.filter(a => a.node.type === 'rule'),
+      templates: all.filter(a => a.node.type === 'template'),
+      insights: all.filter(a => a.node.type === 'insight'),
+    };
+  }
+
+  getStrongestSynapses(limit: number = 20): SynapseRecord[] {
+    return this.repo.topByWeight(limit);
+  }
+
+  getDiverseSynapses(perType: number = 25): SynapseRecord[] {
+    return this.repo.topDiverse(perType);
+  }
+
+  getNetworkStats(): NetworkStats {
+    return {
+      totalNodes: this.repo.countNodes(),
+      totalSynapses: this.repo.totalCount(),
+      avgWeight: this.repo.avgWeight(),
+      nodesByType: {} as Record<NodeType, number>,
+      synapsesByType: this.repo.countByType() as Record<SynapseType, number>,
+    };
+  }
+}

package/src/types/config.types.ts

@@ -0,0 +1,79 @@
+export interface IpcConfig {
+  pipeName: string;
+  timeout: number;
+}
+
+export interface LearningConfig {
+  intervalMs: number;
+  minOccurrences: number;
+  minConfidence: number;
+  pruneThreshold: number;
+  decayHalfLifeDays: number;
+}
+
+export interface SynapsesConfig {
+  initialWeight: number;
+  learningRate: number;
+  decayHalfLifeDays: number;
+  pruneThreshold: number;
+  decayAfterDays: number;
+  maxDepth: number;
+  minActivationWeight: number;
+}
+
+export interface ResearchConfig {
+  intervalMs: number;
+  initialDelayMs: number;
+  minDataPoints: number;
+  trendWindowDays: number;
+  insightExpiryDays: number;
+}
+
+export interface MatchingConfig {
+  similarityThreshold: number;
+  maxResults: number;
+}
+
+export interface ApiConfig {
+  port: number;
+  enabled: boolean;
+  apiKey?: string;
+}
+
+export interface McpHttpConfig {
+  port: number;
+  enabled: boolean;
+}
+
+export interface DashboardConfig {
+  port: number;
+  enabled: boolean;
+}
+
+export interface LogConfig {
+  level: string;
+  file: string;
+  maxSize: number;
+  maxFiles: number;
+}
+
+export interface RetentionConfig {
+  postDays: number;
+  strategyDays: number;
+  insightDays: number;
+}
+
+export interface MarketingBrainConfig {
+  dataDir: string;
+  dbPath: string;
+  ipc: IpcConfig;
+  api: ApiConfig;
+  mcpHttp: McpHttpConfig;
+  dashboard: DashboardConfig;
+  learning: LearningConfig;
+  matching: MatchingConfig;
+  synapses: SynapsesConfig;
+  research: ResearchConfig;
+  log: LogConfig;
+  retention: RetentionConfig;
+}

package/src/types/ipc.types.ts

@@ -0,0 +1,8 @@
+export interface IpcMessage {
+  id: string;
+  type: 'request' | 'response' | 'notification';
+  method?: string;
+  params?: unknown;
+  result?: unknown;
+  error?: { code: number; message: string };
+}