@timmeck/brain 1.9.0 → 2.0.0

package/src/research/synergy-detector.ts

@@ -1,126 +0,0 @@
-import type { ResearchConfig } from '../types/config.types.js';
-import type { SynapseRepository } from '../db/repositories/synapse.repository.js';
-import type { CodeModuleRepository } from '../db/repositories/code-module.repository.js';
-import type { SolutionRepository } from '../db/repositories/solution.repository.js';
-import type { ErrorRepository } from '../db/repositories/error.repository.js';
-import type { ProjectRepository } from '../db/repositories/project.repository.js';
-import type { InsightRepository } from '../db/repositories/insight.repository.js';
-import { getLogger } from '../utils/logger.js';
-
-/**
- * Detects synergies: module pairs, transferable solutions, workflow patterns.
- */
-export class SynergyDetector {
-  private logger = getLogger();
-
-  constructor(
-    private synapseRepo: SynapseRepository,
-    private codeModuleRepo: CodeModuleRepository,
-    private solutionRepo: SolutionRepository,
-    private errorRepo: ErrorRepository,
-    private projectRepo: ProjectRepository,
-    private insightRepo: InsightRepository,
-    private config: ResearchConfig,
-  ) {}
-
-  detect(): number {
-    let insightsCreated = 0;
-
-    insightsCreated += this.findModuleSynergies();
-    insightsCreated += this.findTransferableSolutions();
-
-    this.logger.info(`Synergy detection complete: ${insightsCreated} insights`);
-    return insightsCreated;
-  }
-
-  private findModuleSynergies(): number {
-    const strongSynapses = this.synapseRepo.findByWeight(this.config.synergyMinWeight);
-    const modulePairs = strongSynapses.filter(s =>
-      s.source_type === 'code_module' &&
-      s.target_type === 'code_module' &&
-      s.synapse_type === 'co_occurs',
-    );
-
-    let count = 0;
-    const expiresAt = new Date(Date.now() + this.config.insightExpiryDays * 86400000).toISOString();
-
-    for (const synapse of modulePairs) {
-      const sourceModule = this.codeModuleRepo.getById(synapse.source_id);
-      const targetModule = this.codeModuleRepo.getById(synapse.target_id);
-      if (!sourceModule || !targetModule) continue;
-
-      this.insightRepo.create({
-        type: 'correlation',
-        title: `Strong module pair: ${sourceModule.name} + ${targetModule.name}`,
-        description: `These modules co-occur with weight ${synapse.weight.toFixed(2)}. Consider combining into a shared package.`,
-        evidence: JSON.stringify({
-          sourceId: sourceModule.id,
-          targetId: targetModule.id,
-          sourceName: sourceModule.name,
-          targetName: targetModule.name,
-          weight: synapse.weight,
-        }),
-        priority: Math.min(70, Math.round(synapse.weight * 70)),
-        project_id: sourceModule.project_id,
-        active: 1,
-        expires_at: expiresAt,
-      });
-      count++;
-    }
-
-    return count;
-  }
-
-  private findTransferableSolutions(): number {
-    const projects = this.projectRepo.getAll();
-    if (projects.length < 2) return 0;
-
-    let count = 0;
-    const expiresAt = new Date(Date.now() + this.config.insightExpiryDays * 86400000).toISOString();
-
-    for (let i = 0; i < projects.length; i++) {
-      for (let j = i + 1; j < projects.length; j++) {
-        const projectA = projects[i]!;
-        const projectB = projects[j]!;
-
-        const errorsA = this.errorRepo.findByProject(projectA.id);
-        const errorsB = this.errorRepo.findUnresolved(projectB.id);
-
-        const transferable: number[] = [];
-
-        for (const errorB of errorsB) {
-          const matchingA = errorsA.filter(a => a.type === errorB.type && a.resolved);
-          for (const matchA of matchingA) {
-            const solutions = this.solutionRepo.findForError(matchA.id);
-            for (const sol of solutions) {
-              const rate = this.solutionRepo.successRate(sol.id);
-              if (rate >= 0.5 && !transferable.includes(sol.id)) {
-                transferable.push(sol.id);
-              }
-            }
-          }
-        }
-
-        if (transferable.length >= 2) {
-          this.insightRepo.create({
-            type: 'suggestion',
-            title: `${projectA.name} has solutions for ${projectB.name}`,
-            description: `${transferable.length} successful solutions from ${projectA.name} could help resolve errors in ${projectB.name}.`,
-            evidence: JSON.stringify({
-              sourceProject: projectA.id,
-              targetProject: projectB.id,
-              solutionIds: transferable,
-            }),
-            priority: 50,
-            project_id: projectB.id,
-            active: 1,
-            expires_at: expiresAt,
-          });
-          count++;
-        }
-      }
-    }
-
-    return count;
-  }
-}

package/src/research/template-extractor.ts

@@ -1,130 +0,0 @@
-import type { ResearchConfig } from '../types/config.types.js';
-import type { CodeModuleRepository } from '../db/repositories/code-module.repository.js';
-import type { ProjectRepository } from '../db/repositories/project.repository.js';
-import type { InsightRepository } from '../db/repositories/insight.repository.js';
-import { getLogger } from '../utils/logger.js';
-
-/**
- * Identifies code modules adapted across projects that can be generalized into templates.
- */
-export class TemplateExtractor {
-  private logger = getLogger();
-
-  constructor(
-    private codeModuleRepo: CodeModuleRepository,
-    private projectRepo: ProjectRepository,
-    private insightRepo: InsightRepository,
-    private config: ResearchConfig,
-  ) {}
-
-  extract(): number {
-    let insightsCreated = 0;
-
-    insightsCreated += this.findReusableModules();
-    insightsCreated += this.findTemplatingCandidates();
-
-    this.logger.info(`Template extraction complete: ${insightsCreated} insights`);
-    return insightsCreated;
-  }
-
-  private findReusableModules(): number {
-    const projects = this.projectRepo.getAll();
-    if (projects.length < 2) return 0;
-
-    // Collect all modules grouped by fingerprint
-    const byFingerprint = new Map<string, Array<{ projectId: number; projectName: string; moduleId: number; moduleName: string }>>();
-
-    for (const project of projects) {
-      const modules = this.codeModuleRepo.findByProject(project.id);
-      for (const mod of modules) {
-        const existing = byFingerprint.get(mod.fingerprint) ?? [];
-        existing.push({
-          projectId: project.id,
-          projectName: project.name,
-          moduleId: mod.id,
-          moduleName: mod.name,
-        });
-        byFingerprint.set(mod.fingerprint, existing);
-      }
-    }
-
-    let count = 0;
-    const expiresAt = new Date(Date.now() + this.config.insightExpiryDays * 86400000).toISOString();
-
-    for (const [fingerprint, usages] of byFingerprint) {
-      const uniqueProjects = new Set(usages.map(u => u.projectId));
-      if (uniqueProjects.size >= this.config.templateMinAdaptations) {
-        const moduleName = usages[0]!.moduleName;
-        this.insightRepo.create({
-          type: 'pattern',
-          title: `Shared module candidate: ${moduleName}`,
-          description: `Module "${moduleName}" appears identically in ${uniqueProjects.size} projects. Extract as a shared library.`,
-          evidence: JSON.stringify({
-            fingerprint,
-            projectCount: uniqueProjects.size,
-            usages: usages.map(u => ({ project: u.projectName, moduleId: u.moduleId })),
-          }),
-          priority: Math.min(80, 30 + uniqueProjects.size * 15),
-          project_id: null,
-          active: 1,
-          expires_at: expiresAt,
-        });
-        count++;
-      }
-    }
-
-    return count;
-  }
-
-  private findTemplatingCandidates(): number {
-    const projects = this.projectRepo.getAll();
-    if (projects.length < 2) return 0;
-
-    // Group modules by name across projects (same name, different fingerprint = adaptation)
-    const byName = new Map<string, Array<{ projectId: number; projectName: string; moduleId: number; reusability: number }>>();
-
-    for (const project of projects) {
-      const modules = this.codeModuleRepo.findByProject(project.id);
-      for (const mod of modules) {
-        const existing = byName.get(mod.name) ?? [];
-        existing.push({
-          projectId: project.id,
-          projectName: project.name,
-          moduleId: mod.id,
-          reusability: mod.reusability_score,
-        });
-        byName.set(mod.name, existing);
-      }
-    }
-
-    let count = 0;
-    const expiresAt = new Date(Date.now() + this.config.insightExpiryDays * 86400000).toISOString();
-
-    for (const [name, usages] of byName) {
-      const uniqueProjects = new Set(usages.map(u => u.projectId));
-      if (uniqueProjects.size >= this.config.templateMinAdaptations) {
-        const avgReusability = usages.reduce((sum, u) => sum + u.reusability, 0) / usages.length;
-        if (avgReusability >= 0.5) {
-          this.insightRepo.create({
-            type: 'suggestion',
-            title: `Template candidate: ${name}`,
-            description: `"${name}" exists in ${uniqueProjects.size} projects as adaptations (avg reusability ${Math.round(avgReusability * 100)}%). Generalize into parameterized template.`,
-            evidence: JSON.stringify({
-              name,
-              projectCount: uniqueProjects.size,
-              avgReusability,
-              usages: usages.map(u => ({ project: u.projectName, moduleId: u.moduleId })),
-            }),
-            priority: Math.min(75, 25 + uniqueProjects.size * 10 + Math.round(avgReusability * 20)),
-            project_id: null,
-            active: 1,
-            expires_at: expiresAt,
-          });
-          count++;
-        }
-      }
-    }
-
-    return count;
-  }
-}

package/src/research/trend-analyzer.ts

@@ -1,127 +0,0 @@
-import type { ResearchConfig } from '../types/config.types.js';
-import type { ErrorRepository } from '../db/repositories/error.repository.js';
-import type { SolutionRepository } from '../db/repositories/solution.repository.js';
-import type { ProjectRepository } from '../db/repositories/project.repository.js';
-import type { InsightRepository } from '../db/repositories/insight.repository.js';
-import { getLogger } from '../utils/logger.js';
-
-/**
- * Analyzes error frequency and solution success rate trends over time windows.
- */
-export class TrendAnalyzer {
-  private logger = getLogger();
-
-  constructor(
-    private errorRepo: ErrorRepository,
-    private solutionRepo: SolutionRepository,
-    private projectRepo: ProjectRepository,
-    private insightRepo: InsightRepository,
-    private config: ResearchConfig,
-  ) {}
-
-  analyze(): number {
-    const projects = this.projectRepo.getAll();
-    let insightsCreated = 0;
-
-    for (const project of projects) {
-      insightsCreated += this.analyzeErrorTrend(project.id, project.name);
-      insightsCreated += this.analyzeSolutionTrend(project.id, project.name);
-    }
-
-    this.logger.info(`Trend analysis complete: ${insightsCreated} insights`);
-    return insightsCreated;
-  }
-
-  private analyzeErrorTrend(projectId: number, projectName: string): number {
-    const windowDays = this.config.trendWindowDays;
-    const now = Date.now();
-    const recentSince = new Date(now - windowDays * 86400000).toISOString();
-    const previousSince = new Date(now - windowDays * 2 * 86400000).toISOString();
-
-    const recentErrors = this.errorRepo.countSince(recentSince, projectId);
-    const allSinceDouble = this.errorRepo.countSince(previousSince, projectId);
-    const previousErrors = allSinceDouble - recentErrors;
-
-    if (previousErrors <= 0) return 0;
-
-    const changeRate = (recentErrors - previousErrors) / previousErrors;
-    const expiresAt = new Date(Date.now() + this.config.insightExpiryDays * 86400000).toISOString();
-
-    if (changeRate > 0.5) {
-      this.insightRepo.create({
-        type: 'warning',
-        title: `Error rate rising in ${projectName}`,
-        description: `${Math.round(changeRate * 100)}% more errors in the last ${windowDays} days vs previous window. Check recent changes: new dependencies, refactoring, or API changes.`,
-        evidence: JSON.stringify({ recentErrors, previousErrors, changeRate, windowDays }),
-        priority: Math.min(90, 50 + Math.round(changeRate * 30)),
-        project_id: projectId,
-        active: 1,
-        expires_at: expiresAt,
-      });
-      return 1;
-    }
-
-    if (changeRate < -0.3) {
-      this.insightRepo.create({
-        type: 'pattern',
-        title: `Error rate declining in ${projectName}`,
-        description: `${Math.round(-changeRate * 100)}% fewer errors in the last ${windowDays} days. Whatever you're doing is working.`,
-        evidence: JSON.stringify({ recentErrors, previousErrors, changeRate, windowDays }),
-        priority: 20,
-        project_id: projectId,
-        active: 1,
-        expires_at: expiresAt,
-      });
-      return 1;
-    }
-
-    return 0;
-  }
-
-  private analyzeSolutionTrend(projectId: number, projectName: string): number {
-    const errors = this.errorRepo.findByProject(projectId);
-    if (errors.length < this.config.minDataPoints) return 0;
-
-    let totalRate = 0;
-    let recentRate = 0;
-    let totalCount = 0;
-    let recentCount = 0;
-    const recentCutoff = new Date(Date.now() - this.config.trendWindowDays * 86400000).toISOString();
-
-    for (const error of errors) {
-      const solutions = this.solutionRepo.findForError(error.id);
-      for (const sol of solutions) {
-        const rate = this.solutionRepo.successRate(sol.id);
-        totalRate += rate;
-        totalCount++;
-
-        if (sol.updated_at >= recentCutoff) {
-          recentRate += rate;
-          recentCount++;
-        }
-      }
-    }
-
-    if (totalCount === 0 || recentCount === 0) return 0;
-
-    const avgTotal = totalRate / totalCount;
-    const avgRecent = recentRate / recentCount;
-
-    if (avgRecent < avgTotal - 0.15 && totalCount >= this.config.minDataPoints) {
-      const expiresAt = new Date(Date.now() + this.config.insightExpiryDays * 86400000).toISOString();
-      this.insightRepo.create({
-        type: 'warning',
-        title: `Solution quality declining in ${projectName}`,
-        description: `Recent success rate ${Math.round(avgRecent * 100)}% vs overall ${Math.round(avgTotal * 100)}%. Solutions are becoming less effective.`,
-        evidence: JSON.stringify({ avgRecent, avgTotal, recentCount, totalCount }),
-        priority: 60,
-        project_id: projectId,
-        active: 1,
-        expires_at: expiresAt,
-      });
-      return 1;
-    }
-
-    return 0;
-  }
-}

package/src/services/analytics.service.ts

@@ -1,226 +0,0 @@
-import type { ErrorRecord } from '../types/error.types.js';
-import type { ErrorRepository } from '../db/repositories/error.repository.js';
-import type { SolutionRepository } from '../db/repositories/solution.repository.js';
-import type { CodeModuleRepository } from '../db/repositories/code-module.repository.js';
-import type { RuleRepository } from '../db/repositories/rule.repository.js';
-import type { AntipatternRepository } from '../db/repositories/antipattern.repository.js';
-import type { InsightRepository } from '../db/repositories/insight.repository.js';
-import type { SynapseManager } from '../synapses/synapse-manager.js';
-import type { NetworkStats } from '../types/synapse.types.js';
-
-export interface ProjectSummary {
-  errors: { total: number; unresolved: number; last7d: number };
-  solutions: { total: number };
-  rules: { active: number };
-  antipatterns: { total: number };
-  modules: { total: number };
-  insights: { active: number };
-  healthScore?: number;
-}
-
-export interface NetworkOverview {
-  stats: NetworkStats;
-  strongestSynapses: Array<{
-    id: number;
-    source: string;
-    target: string;
-    type: string;
-    weight: number;
-  }>;
-}
-
-export class AnalyticsService {
-  constructor(
-    private errorRepo: ErrorRepository,
-    private solutionRepo: SolutionRepository,
-    private codeModuleRepo: CodeModuleRepository,
-    private ruleRepo: RuleRepository,
-    private antipatternRepo: AntipatternRepository,
-    private insightRepo: InsightRepository,
-    private synapseManager: SynapseManager,
-  ) {}
-
-  getSummary(projectId?: number): ProjectSummary {
-    const sevenDaysAgo = new Date(Date.now() - 7 * 86400000).toISOString();
-
-    const unresolvedErrors = this.errorRepo.findUnresolved(projectId);
-    const allErrors = projectId ? this.errorRepo.findByProject(projectId) : [];
-    const last7dCount = this.errorRepo.countSince(sevenDaysAgo, projectId);
-
-    const rules = this.ruleRepo.findActive(projectId);
-    const antipatterns = projectId
-      ? this.antipatternRepo.findByProject(projectId)
-      : this.antipatternRepo.findGlobal();
-
-    const moduleCount = projectId
-      ? this.codeModuleRepo.findByProject(projectId).length
-      : this.codeModuleRepo.countAll();
-    const insights = this.insightRepo.findActive(projectId);
-
-    return {
-      errors: {
-        total: allErrors.length,
-        unresolved: unresolvedErrors.length,
-        last7d: last7dCount,
-      },
-      solutions: { total: 0 }, // solutions are global, not per-project
-      rules: { active: rules.length },
-      antipatterns: { total: antipatterns.length },
-      modules: { total: moduleCount },
-      insights: { active: insights.length },
-    };
-  }
-
-  computeHealthScore(projectId?: number): number {
-    const summary = this.getSummary(projectId);
-    const networkStats = this.synapseManager.getNetworkStats();
-
-    let score = 0;
-    let maxScore = 0;
-
-    // Data Volume (30 points)
-    maxScore += 30;
-    const dataVolume = summary.errors.total + (summary.modules.total * 2) + summary.solutions.total;
-    score += Math.min(30, dataVolume * 0.3);
-
-    // Synapse Density (20 points) - more connections = richer network
-    maxScore += 20;
-    const synapseDensity = networkStats.totalSynapses / Math.max(1, networkStats.totalNodes);
-    score += Math.min(20, synapseDensity * 5);
-
-    // Solution Coverage (20 points) - resolved errors vs total
-    maxScore += 20;
-    if (summary.errors.total > 0) {
-      const resolvedRate = 1 - (summary.errors.unresolved / summary.errors.total);
-      score += resolvedRate * 20;
-    } else {
-      score += 10; // No errors = neutral
-    }
-
-    // Learning Activity (15 points) - active rules + insights
-    maxScore += 15;
-    const learningActivity = summary.rules.active + summary.insights.active;
-    score += Math.min(15, learningActivity * 1.5);
-
-    // Error Trend (15 points) - fewer recent errors = better
-    maxScore += 15;
-    if (summary.errors.total > 0) {
-      const recentRatio = summary.errors.last7d / Math.max(1, summary.errors.total);
-      // Low recent ratio = health is good (errors decreasing)
-      score += Math.max(0, 15 - recentRatio * 30);
-    } else {
-      score += 15;
-    }
-
-    return Math.round((score / maxScore) * 100);
-  }
-
-  getTimeSeries(projectId?: number, days: number = 30): Array<{ date: string; errors: number; solutions: number }> {
-    const series: Array<{ date: string; errors: number; solutions: number }> = [];
-
-    for (let i = days - 1; i >= 0; i--) {
-      const dayStart = new Date(Date.now() - (i + 1) * 86400000).toISOString();
-      const dayEnd = new Date(Date.now() - i * 86400000).toISOString();
-
-      const errorsInDay = this.errorRepo.countSince(dayStart, projectId) - this.errorRepo.countSince(dayEnd, projectId);
-
-      series.push({
-        date: dayStart.split('T')[0]!,
-        errors: Math.max(0, errorsInDay),
-        solutions: 0, // Approximation
-      });
-    }
-
-    return series;
-  }
-
-  explainError(errorId: number): {
-    error: ErrorRecord | undefined;
-    solutions: Array<{ id: number; description: string; confidence: number; successRate: number }>;
-    chain: { parents: ErrorRecord[]; children: ErrorRecord[] };
-    relatedErrors: Array<{ id: number; type: string; message: string; similarity: number }>;
-    rules: Array<{ id: number; pattern: string; action: string; confidence: number }>;
-    insights: Array<{ id: number; type: string; title: string }>;
-    synapseConnections: number;
-  } {
-    const error = this.errorRepo.getById(errorId);
-    if (!error) {
-      return {
-        error: undefined, solutions: [], chain: { parents: [], children: [] },
-        relatedErrors: [], rules: [], insights: [], synapseConnections: 0,
-      };
-    }
-
-    // Solutions
-    const solutions = this.solutionRepo.findForError(errorId).map(s => ({
-      id: s.id,
-      description: s.description,
-      confidence: s.confidence,
-      successRate: this.solutionRepo.successRate(s.id),
-    }));
-
-    // Error chain
-    const parents = this.errorRepo.findChainParents(errorId);
-    const children = this.errorRepo.findChainChildren(errorId);
-
-    // Related via synapses
-    const context = this.synapseManager.getErrorContext(errorId);
-    const relatedErrors = context.relatedErrors.map(r => {
-      const e = this.errorRepo.getById(r.node.id);
-      return {
-        id: r.node.id,
-        type: e?.type ?? 'unknown',
-        message: e?.message ?? '',
-        similarity: r.activation,
-      };
-    });
-
-    // Prevention rules
-    const matchedRules = this.ruleRepo.findActive(error.project_id);
-    const rules = matchedRules
-      .filter(r => {
-        try { return new RegExp(r.pattern, 'i').test(`${error.type}: ${error.message}`); }
-        catch { return false; }
-      })
-      .map(r => ({ id: r.id, pattern: r.pattern, action: r.action, confidence: r.confidence }));
-
-    // Related insights
-    const insights = context.insights.map(i => ({
-      id: i.node.id,
-      type: i.node.type,
-      title: `Insight #${i.node.id}`,
-    }));
-
-    // Total synapse connections
-    const allConnections = this.synapseManager.activate({ type: 'error', id: errorId });
-
-    return {
-      error,
-      solutions,
-      chain: { parents, children },
-      relatedErrors,
-      rules,
-      insights,
-      synapseConnections: allConnections.length,
-    };
-  }
-
-  getNetworkOverview(limit: number = 10): NetworkOverview {
-    const stats = this.synapseManager.getNetworkStats();
-    // Use diverse sampling for dashboard (spread across synapse types)
-    const diverse = limit >= 30
-      ? this.synapseManager.getDiverseSynapses(Math.ceil(limit / 3))
-      : this.synapseManager.getStrongestSynapses(limit);
-
-    return {
-      stats,
-      strongestSynapses: diverse.map(s => ({
-        id: s.id,
-        source: `${s.source_type}:${s.source_id}`,
-        target: `${s.target_type}:${s.target_id}`,
-        type: s.synapse_type,
-        weight: s.weight,
-      })),
-    };
-  }
-}