@timmeck/brain 1.8.5 → 2.0.0

package/src/research/insight-generator.ts

@@ -1,123 +0,0 @@
-import type { ResearchConfig } from '../types/config.types.js';
-import type { ProjectRepository } from '../db/repositories/project.repository.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 { InsightRepository } from '../db/repositories/insight.repository.js';
-import { getLogger } from '../utils/logger.js';
-
-/**
- * Generates project suggestions, tool ideas, and optimization hints.
- */
-export class InsightGenerator {
-  private logger = getLogger();
-
-  constructor(
-    private projectRepo: ProjectRepository,
-    private errorRepo: ErrorRepository,
-    private solutionRepo: SolutionRepository,
-    private codeModuleRepo: CodeModuleRepository,
-    private insightRepo: InsightRepository,
-    private config: ResearchConfig,
-  ) {}
-
-  generate(): number {
-    let insightsCreated = 0;
-
-    insightsCreated += this.suggestRefactoring();
-    insightsCreated += this.suggestErrorTypeTools();
-    this.reprioritizeInsights();
-
-    this.logger.info(`Insight generation complete: ${insightsCreated} new insights`);
-    return insightsCreated;
-  }
-
-  private suggestRefactoring(): number {
-    const projects = this.projectRepo.getAll();
-    let count = 0;
-    const expiresAt = new Date(Date.now() + this.config.insightExpiryDays * 86400000).toISOString();
-
-    for (const project of projects) {
-      const modules = this.codeModuleRepo.findByProject(project.id);
-      const problematic = modules.filter(m =>
-        (m.complexity ?? 0) > 10 && m.reusability_score < 0.3 && m.lines_of_code > 50,
-      );
-
-      if (problematic.length > 0) {
-        this.insightRepo.create({
-          type: 'optimization',
-          title: `${problematic.length} complex modules need refactoring in ${project.name}`,
-          description: `These modules have high complexity (>10), low reusability (<30%), and are non-trivial (>50 LOC). Refactoring would improve maintainability.`,
-          evidence: JSON.stringify({
-            modules: problematic.map(m => ({
-              id: m.id,
-              name: m.name,
-              complexity: m.complexity,
-              reusability: m.reusability_score,
-              loc: m.lines_of_code,
-            })),
-          }),
-          priority: Math.min(70, 30 + problematic.length * 10),
-          project_id: project.id,
-          active: 1,
-          expires_at: expiresAt,
-        });
-        count++;
-      }
-    }
-
-    return count;
-  }
-
-  private suggestErrorTypeTools(): number {
-    const projects = this.projectRepo.getAll();
-    let count = 0;
-    const expiresAt = new Date(Date.now() + this.config.insightExpiryDays * 86400000).toISOString();
-
-    for (const project of projects) {
-      const errors = this.errorRepo.findByProject(project.id);
-      if (errors.length < this.config.minDataPoints) continue;
-
-      // Group errors by type
-      const byType = new Map<string, number>();
-      for (const error of errors) {
-        byType.set(error.type, (byType.get(error.type) ?? 0) + error.occurrence_count);
-      }
-
-      // Find dominant error types
-      for (const [errorType, totalOccurrences] of byType) {
-        if (totalOccurrences >= this.config.gapMinOccurrences * 3) {
-          this.insightRepo.create({
-            type: 'suggestion',
-            title: `Frequent error type: ${errorType} in ${project.name}`,
-            description: `${errorType} has ${totalOccurrences} total occurrences. Consider adding linting rules, type checking, or tooling to prevent this class of errors.`,
-            evidence: JSON.stringify({ errorType, totalOccurrences, projectId: project.id }),
-            priority: Math.min(65, 30 + Math.round(totalOccurrences / 5)),
-            project_id: project.id,
-            active: 1,
-            expires_at: expiresAt,
-          });
-          count++;
-        }
-      }
-    }
-
-    return count;
-  }
-
-  private reprioritizeInsights(): void {
-    const activeInsights = this.insightRepo.findActive();
-
-    for (const insight of activeInsights) {
-      if (insight.type === 'warning') {
-        const ageMs = Date.now() - new Date(insight.created_at).getTime();
-        const ageDays = ageMs / 86400000;
-        if (ageDays > 3 && insight.priority < 80) {
-          this.insightRepo.update(insight.id, {
-            priority: Math.min(85, insight.priority + 10),
-          });
-        }
-      }
-    }
-  }
-}

package/src/research/research-engine.ts

@@ -1,116 +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 { CodeModuleRepository } from '../db/repositories/code-module.repository.js';
-import type { SynapseRepository } from '../db/repositories/synapse.repository.js';
-import type { InsightRepository } from '../db/repositories/insight.repository.js';
-import type { SynapseManager } from '../synapses/synapse-manager.js';
-import type { ResearchCycleResult } from '../types/research.types.js';
-import { TrendAnalyzer } from './trend-analyzer.js';
-import { GapAnalyzer } from './gap-analyzer.js';
-import { SynergyDetector } from './synergy-detector.js';
-import { TemplateExtractor } from './template-extractor.js';
-import { InsightGenerator } from './insight-generator.js';
-import { getLogger } from '../utils/logger.js';
-
-export class ResearchEngine {
-  private timer: ReturnType<typeof setInterval> | null = null;
-  private delayTimer: ReturnType<typeof setTimeout> | null = null;
-  private logger = getLogger();
-
-  private trendAnalyzer: TrendAnalyzer;
-  private gapAnalyzer: GapAnalyzer;
-  private synergyDetector: SynergyDetector;
-  private templateExtractor: TemplateExtractor;
-  private insightGenerator: InsightGenerator;
-
-  constructor(
-    private config: ResearchConfig,
-    private errorRepo: ErrorRepository,
-    private solutionRepo: SolutionRepository,
-    private projectRepo: ProjectRepository,
-    private codeModuleRepo: CodeModuleRepository,
-    private synapseRepo: SynapseRepository,
-    private insightRepo: InsightRepository,
-    private synapseManager: SynapseManager,
-  ) {
-    this.trendAnalyzer = new TrendAnalyzer(errorRepo, solutionRepo, projectRepo, insightRepo, config);
-    this.gapAnalyzer = new GapAnalyzer(errorRepo, solutionRepo, synapseRepo, projectRepo, insightRepo, config);
-    this.synergyDetector = new SynergyDetector(synapseRepo, codeModuleRepo, solutionRepo, errorRepo, projectRepo, insightRepo, config);
-    this.templateExtractor = new TemplateExtractor(codeModuleRepo, projectRepo, insightRepo, config);
-    this.insightGenerator = new InsightGenerator(projectRepo, errorRepo, solutionRepo, codeModuleRepo, insightRepo, config);
-  }
-
-  start(): void {
-    this.logger.info(`Research engine starting (interval: ${this.config.intervalMs}ms, initial delay: ${this.config.initialDelayMs}ms)`);
-    this.delayTimer = setTimeout(() => {
-      this.runCycle();
-      this.timer = setInterval(() => this.runCycle(), this.config.intervalMs);
-    }, this.config.initialDelayMs);
-  }
-
-  stop(): void {
-    if (this.delayTimer) {
-      clearTimeout(this.delayTimer);
-      this.delayTimer = null;
-    }
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    this.logger.info('Research engine stopped');
-  }
-
-  runCycle(): ResearchCycleResult {
-    const start = Date.now();
-    this.logger.info('Research cycle starting');
-
-    const result: ResearchCycleResult = {
-      insightsGenerated: 0,
-      patternsFound: 0,
-      correlationsFound: 0,
-      duration: 0,
-    };
-
-    // Phase 1: Trend analysis
-    const trends = this.trendAnalyzer.analyze();
-    result.patternsFound += trends;
-    result.insightsGenerated += trends;
-
-    // Phase 2: Gap analysis
-    const gaps = this.gapAnalyzer.analyze();
-    result.insightsGenerated += gaps;
-
-    // Phase 3: Synergy detection
-    const synergies = this.synergyDetector.detect();
-    result.correlationsFound += synergies;
-    result.insightsGenerated += synergies;
-
-    // Phase 4: Template extraction
-    const templates = this.templateExtractor.extract();
-    result.patternsFound += templates;
-    result.insightsGenerated += templates;
-
-    // Phase 5: Insight generation
-    const generated = this.insightGenerator.generate();
-    result.insightsGenerated += generated;
-
-    // Phase 6: Insight prioritization (expire old insights)
-    const expired = this.insightRepo.expire();
-    if (expired > 0) {
-      this.logger.info(`Expired ${expired} outdated insights`);
-    }
-
-    // Phase 7: Synapse maintenance
-    const decay = this.synapseManager.runDecay();
-    this.logger.debug(`Synapse maintenance: ${decay.decayed} decayed, ${decay.pruned} pruned`);
-
-    result.duration = Date.now() - start;
-    this.logger.info(
-      `Research cycle complete: ${result.insightsGenerated} insights, ${result.patternsFound} patterns, ${result.correlationsFound} correlations (${result.duration}ms)`,
-    );
-
-    return result;
-  }
-}

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