@timmeck/brain 1.0.0

package/src/parsing/parsers/rust.ts

@@ -0,0 +1,50 @@
+import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
+import path from 'node:path';
+
+const RUST_ERROR_RE = /error(?:\[E(\d+)\])?: (.+)/;
+const RUST_LOCATION_RE = /^\s*--> (.+):(\d+):(\d+)/m;
+const RUST_NOTE_RE = /^\s*= note: (.+)/gm;
+
+export const rustParser: ErrorParser = {
+  name: 'rust',
+  priority: 10,
+
+  canParse(input: string): boolean {
+    return /error\[E\d+\]:/.test(input) || /^error:/.test(input);
+  },
+
+  parse(input: string): ParsedError | null {
+    const errMatch = RUST_ERROR_RE.exec(input);
+    if (!errMatch) return null;
+
+    const message = errMatch[2]!.trim();
+    const errorType = errMatch[1] ? `E${errMatch[1]}` : 'CompilerError';
+
+    const frames: StackFrame[] = [];
+    let sourceFile: string | null = null;
+    let sourceLine: number | null = null;
+
+    const locMatch = RUST_LOCATION_RE.exec(input);
+    if (locMatch) {
+      sourceFile = locMatch[1]!;
+      sourceLine = parseInt(locMatch[2]!, 10);
+      frames.push({
+        function_name: null,
+        file_path: locMatch[1]!,
+        line_number: parseInt(locMatch[2]!, 10),
+        column_number: parseInt(locMatch[3]!, 10),
+        normalized: `<compiler>@${path.basename(locMatch[1]!)}`,
+      });
+    }
+
+    return {
+      errorType,
+      message,
+      stackTrace: input,
+      frames,
+      sourceFile,
+      sourceLine,
+      language: 'rust',
+    };
+  },
+};

package/src/parsing/parsers/shell.ts

@@ -0,0 +1,42 @@
+import type { ErrorParser, ParsedError } from '../types.js';
+
+const ERROR_MAP: Array<{ pattern: RegExp; type: string }> = [
+  { pattern: /command not found/i, type: 'CommandNotFound' },
+  { pattern: /Permission denied|EACCES/i, type: 'PermissionError' },
+  { pattern: /No such file or directory|ENOENT/i, type: 'FileNotFound' },
+  { pattern: /ECONNREFUSED/i, type: 'ConnectionRefused' },
+  { pattern: /EADDRINUSE/i, type: 'AddressInUse' },
+  { pattern: /ETIMEDOUT|ESOCKETTIMEDOUT/i, type: 'Timeout' },
+  { pattern: /ENOMEM/i, type: 'OutOfMemory' },
+];
+
+export const shellParser: ErrorParser = {
+  name: 'shell',
+  priority: 5,
+
+  canParse(input: string): boolean {
+    return ERROR_MAP.some(e => e.pattern.test(input));
+  },
+
+  parse(input: string): ParsedError | null {
+    let errorType = 'ShellError';
+    for (const entry of ERROR_MAP) {
+      if (entry.pattern.test(input)) {
+        errorType = entry.type;
+        break;
+      }
+    }
+
+    const firstLine = input.trim().split('\n')[0] ?? input;
+
+    return {
+      errorType,
+      message: firstLine,
+      stackTrace: null,
+      frames: [],
+      sourceFile: null,
+      sourceLine: null,
+      language: 'shell',
+    };
+  },
+};

package/src/parsing/types.ts

@@ -0,0 +1,47 @@
+export interface StackFrame {
+  function_name: string | null;
+  file_path: string | null;
+  line_number: number | null;
+  column_number: number | null;
+  normalized: string | null;
+}
+
+export interface ParsedError {
+  errorType: string;
+  message: string;
+  stackTrace: string | null;
+  frames: StackFrame[];
+  sourceFile: string | null;
+  sourceLine: number | null;
+  language: string | null;
+}
+
+export interface ErrorParser {
+  name: string;
+  priority: number;
+  canParse(input: string): boolean;
+  parse(input: string): ParsedError | null;
+}
+
+export class ErrorParserRegistry {
+  private parsers: ErrorParser[] = [];
+
+  register(parser: ErrorParser): void {
+    this.parsers.push(parser);
+    this.parsers.sort((a, b) => b.priority - a.priority);
+  }
+
+  parse(input: string): ParsedError | null {
+    for (const parser of this.parsers) {
+      if (parser.canParse(input)) {
+        const result = parser.parse(input);
+        if (result) return result;
+      }
+    }
+    return null;
+  }
+
+  getRegistered(): string[] {
+    return this.parsers.map(p => p.name);
+  }
+}

package/src/research/gap-analyzer.ts

@@ -0,0 +1,135 @@
+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 { SynapseRepository } from '../db/repositories/synapse.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 gaps: unresolved recurring errors, missing solutions, isolated synapse nodes.
+ */
+export class GapAnalyzer {
+  private logger = getLogger();
+
+  constructor(
+    private errorRepo: ErrorRepository,
+    private solutionRepo: SolutionRepository,
+    private synapseRepo: SynapseRepository,
+    private projectRepo: ProjectRepository,
+    private insightRepo: InsightRepository,
+    private config: ResearchConfig,
+  ) {}
+
+  analyze(): number {
+    let insightsCreated = 0;
+
+    insightsCreated += this.findUnresolvedRecurring();
+    insightsCreated += this.findFailedSolutions();
+    insightsCreated += this.findIsolatedNodes();
+
+    this.logger.info(`Gap analysis complete: ${insightsCreated} insights`);
+    return insightsCreated;
+  }
+
+  private findUnresolvedRecurring(): number {
+    const unresolved = this.errorRepo.findUnresolved();
+    const recurring = unresolved.filter(e => e.occurrence_count >= this.config.gapMinOccurrences);
+    let count = 0;
+    const expiresAt = new Date(Date.now() + this.config.insightExpiryDays * 86400000).toISOString();
+
+    for (const error of recurring) {
+      const solutions = this.solutionRepo.findForError(error.id);
+      if (solutions.length === 0) {
+        this.insightRepo.create({
+          type: 'warning',
+          title: `Unresolved recurring error: ${error.type}`,
+          description: `"${error.message.substring(0, 80)}..." has occurred ${error.occurrence_count} times with no solution.`,
+          evidence: JSON.stringify({ errorId: error.id, occurrences: error.occurrence_count, type: error.type }),
+          priority: Math.min(95, 40 + error.occurrence_count * 5),
+          project_id: error.project_id,
+          active: 1,
+          expires_at: expiresAt,
+        });
+        count++;
+      }
+    }
+
+    return count;
+  }
+
+  private findFailedSolutions(): 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.findUnresolved(project.id);
+      for (const error of errors) {
+        if (error.occurrence_count < this.config.gapMinOccurrences) continue;
+
+        const solutions = this.solutionRepo.findForError(error.id);
+        if (solutions.length < 2) continue;
+
+        const allFailed = solutions.every(s => {
+          const rate = this.solutionRepo.successRate(s.id);
+          return rate < 0.3;
+        });
+
+        if (allFailed) {
+          this.insightRepo.create({
+            type: 'warning',
+            title: `All solutions failing for: ${error.type}`,
+            description: `${solutions.length} solutions tried for "${error.message.substring(0, 60)}..." but all have <30% success rate.`,
+            evidence: JSON.stringify({
+              errorId: error.id,
+              solutionCount: solutions.length,
+              solutionIds: solutions.map(s => s.id),
+            }),
+            priority: Math.min(90, 50 + solutions.length * 10),
+            project_id: project.id,
+            active: 1,
+            expires_at: expiresAt,
+          });
+          count++;
+        }
+      }
+    }
+
+    return count;
+  }
+
+  private findIsolatedNodes(): 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);
+      let projectIsolated = 0;
+
+      for (const error of errors) {
+        const connections = this.synapseRepo.findConnected('error', error.id);
+        if (connections.length === 0) {
+          projectIsolated++;
+        }
+      }
+
+      if (projectIsolated > 5) {
+        this.insightRepo.create({
+          type: 'optimization',
+          title: `${projectIsolated} errors without connections in ${project.name}`,
+          description: `These errors have no synapses to solutions, modules, or other errors. Brain cannot contextualize them.`,
+          evidence: JSON.stringify({ projectId: project.id, isolatedCount: projectIsolated }),
+          priority: 25,
+          project_id: project.id,
+          active: 1,
+          expires_at: expiresAt,
+        });
+        count++;
+      }
+    }
+
+    return count;
+  }
+}

package/src/research/insight-generator.ts

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

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

@@ -0,0 +1,126 @@
+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;
+  }
+}