@timmeck/marketing-brain 0.2.1 → 0.4.0

package/src/services/strategy.service.ts

@@ -1,53 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

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