@timmeck/brain 1.9.0 → 2.0.0

package/src/parsing/parsers/node.ts

@@ -1,69 +0,0 @@
-import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
-import path from 'node:path';
-
-const V8_STACK_RE = /at (?:(.+?) )?\((.+?):(\d+):(\d+)\)/;
-const V8_STACK_BARE_RE = /at (.+?):(\d+):(\d+)/;
-const ERROR_TYPE_RE = /^(\w+(?:Error|Exception|Warning)?): (.+)$/m;
-
-function parseFrames(input: string): StackFrame[] {
-  const frames: StackFrame[] = [];
-  for (const line of input.split('\n')) {
-    const trimmed = line.trim();
-    let match = V8_STACK_RE.exec(trimmed);
-    if (match) {
-      frames.push({
-        function_name: match[1] || null,
-        file_path: match[2]!,
-        line_number: parseInt(match[3]!, 10),
-        column_number: parseInt(match[4]!, 10),
-        normalized: `${match[1] || '<anon>'}@${path.basename(match[2]!)}`,
-      });
-      continue;
-    }
-    match = V8_STACK_BARE_RE.exec(trimmed);
-    if (match) {
-      frames.push({
-        function_name: null,
-        file_path: match[1]!,
-        line_number: parseInt(match[2]!, 10),
-        column_number: parseInt(match[3]!, 10),
-        normalized: `<anon>@${path.basename(match[1]!)}`,
-      });
-    }
-  }
-  return frames;
-}
-
-export const nodeParser: ErrorParser = {
-  name: 'node',
-  priority: 10,
-
-  canParse(input: string): boolean {
-    return (
-      /at .+ \(.+:\d+:\d+\)/.test(input) ||
-      /at .+:\d+:\d+/.test(input) ||
-      /^\w*Error:/.test(input) ||
-      /^\w*TypeError:/.test(input)
-    );
-  },
-
-  parse(input: string): ParsedError | null {
-    const typeMatch = ERROR_TYPE_RE.exec(input);
-    if (!typeMatch) return null;
-
-    const errorType = typeMatch[1]!;
-    const message = typeMatch[2]!;
-    const frames = parseFrames(input);
-    const topFrame = frames[0];
-
-    return {
-      errorType,
-      message,
-      stackTrace: input,
-      frames,
-      sourceFile: topFrame?.file_path ?? null,
-      sourceLine: topFrame?.line_number ?? null,
-      language: 'javascript',
-    };
-  },
-};

package/src/parsing/parsers/python.ts

@@ -1,62 +0,0 @@
-import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
-import path from 'node:path';
-
-const FRAME_RE = /File "(.+?)", line (\d+)(?:, in (.+))?/g;
-const ERROR_LINE_RE = /^(\w+(?:Error|Exception|Warning)?): (.+)$/m;
-
-export const pythonParser: ErrorParser = {
-  name: 'python',
-  priority: 10,
-
-  canParse(input: string): boolean {
-    return (
-      /Traceback \(most recent call last\)/.test(input) ||
-      /File ".+", line \d+/.test(input)
-    );
-  },
-
-  parse(input: string): ParsedError | null {
-    const frames: StackFrame[] = [];
-    let match: RegExpExecArray | null;
-    const frameRe = new RegExp(FRAME_RE.source, 'g');
-
-    while ((match = frameRe.exec(input)) !== null) {
-      frames.push({
-        function_name: match[3] || null,
-        file_path: match[1]!,
-        line_number: parseInt(match[2]!, 10),
-        column_number: null,
-        normalized: `${match[3] || '<module>'}@${path.basename(match[1]!)}`,
-      });
-    }
-
-    const lines = input.trim().split('\n');
-    let errorType = 'PythonError';
-    let message = '';
-
-    for (let i = lines.length - 1; i >= 0; i--) {
-      const errMatch = ERROR_LINE_RE.exec(lines[i]!);
-      if (errMatch) {
-        errorType = errMatch[1]!;
-        message = errMatch[2]!;
-        break;
-      }
-    }
-
-    if (!message && lines.length > 0) {
-      message = lines[lines.length - 1]!;
-    }
-
-    const topFrame = frames[frames.length - 1];
-
-    return {
-      errorType,
-      message,
-      stackTrace: input,
-      frames,
-      sourceFile: topFrame?.file_path ?? null,
-      sourceLine: topFrame?.line_number ?? null,
-      language: 'python',
-    };
-  },
-};

package/src/parsing/parsers/rust.ts

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

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

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

@@ -1,135 +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 { 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

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