@timmeck/brain 1.0.0

package/src/research/template-extractor.ts

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

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

@@ -0,0 +1,87 @@
+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 };
+}
+
+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 },
+    };
+  }
+
+  getNetworkOverview(limit: number = 10): NetworkOverview {
+    const stats = this.synapseManager.getNetworkStats();
+    const strongest = this.synapseManager.getStrongestSynapses(limit);
+
+    return {
+      stats,
+      strongestSynapses: strongest.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,
+      })),
+    };
+  }
+}

package/src/services/code.service.ts

@@ -0,0 +1,140 @@
+import type { CodeModuleRecord } from '../types/code.types.js';
+import type { CodeModuleRepository } from '../db/repositories/code-module.repository.js';
+import type { ProjectRepository } from '../db/repositories/project.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import { analyzeCode } from '../code/analyzer.js';
+import { fingerprintCode } from '../code/fingerprint.js';
+import { computeReusabilityScore } from '../code/scorer.js';
+import { detectGranularity } from '../code/registry.js';
+import { findExactMatches, findSemanticMatches } from '../code/matcher.js';
+import { sha256 } from '../utils/hash.js';
+import { getEventBus } from '../utils/events.js';
+import { getLogger } from '../utils/logger.js';
+
+export interface AnalyzeInput {
+  project: string;
+  name: string;
+  filePath: string;
+  language: string;
+  source: string;
+  description?: string;
+}
+
+export interface FindReusableInput {
+  query?: string;
+  language?: string;
+  projectId?: number;
+  limit?: number;
+}
+
+export class CodeService {
+  private logger = getLogger();
+  private eventBus = getEventBus();
+
+  constructor(
+    private codeModuleRepo: CodeModuleRepository,
+    private projectRepo: ProjectRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  analyzeAndRegister(input: AnalyzeInput): { moduleId: number; isNew: boolean; reusabilityScore: number } {
+    // Ensure project exists
+    let project = this.projectRepo.findByName(input.project);
+    if (!project) {
+      const id = this.projectRepo.create({ name: input.project, path: null, language: input.language, framework: null });
+      project = this.projectRepo.getById(id)!;
+    }
+
+    // Analyze the code
+    const analysis = analyzeCode(input.source, input.language);
+    const fingerprint = fingerprintCode(input.source, input.language);
+    const sourceHash = sha256(input.source);
+
+    // Check if module already exists (by fingerprint)
+    const existing = this.codeModuleRepo.findByFingerprint(fingerprint);
+    if (existing) {
+      this.codeModuleRepo.update(existing.id, {
+        source_hash: sourceHash,
+        updated_at: new Date().toISOString(),
+      });
+
+      this.synapseManager.strengthen(
+        { type: 'code_module', id: existing.id },
+        { type: 'project', id: project.id },
+        'uses_module',
+      );
+
+      return { moduleId: existing.id, isNew: false, reusabilityScore: existing.reusability_score };
+    }
+
+    // Compute reusability score
+    const reusabilityScore = computeReusabilityScore({
+      source: input.source,
+      filePath: input.filePath,
+      exports: analysis.exports,
+      internalDeps: analysis.internalDeps,
+      hasTypeAnnotations: analysis.hasTypeAnnotations,
+    });
+
+    const granularity = detectGranularity(input.source, input.language);
+
+    const moduleId = this.codeModuleRepo.create({
+      project_id: project.id,
+      name: input.name,
+      file_path: input.filePath,
+      language: input.language,
+      fingerprint,
+      description: input.description ?? null,
+      source_hash: sourceHash,
+      lines_of_code: analysis.linesOfCode,
+      complexity: null,
+      reusability_score: reusabilityScore,
+    });
+
+    // Create synapse: module ↔ project
+    this.synapseManager.strengthen(
+      { type: 'code_module', id: moduleId },
+      { type: 'project', id: project.id },
+      'uses_module',
+    );
+
+    this.eventBus.emit('module:registered', { moduleId, projectId: project.id });
+    this.logger.info(`Code module registered (id=${moduleId}, name=${input.name}, granularity=${granularity}, score=${reusabilityScore.toFixed(2)})`);
+
+    return { moduleId, isNew: true, reusabilityScore };
+  }
+
+  findReusable(input: FindReusableInput): CodeModuleRecord[] {
+    if (input.query) {
+      return this.codeModuleRepo.search(input.query);
+    }
+    if (input.language) {
+      return this.codeModuleRepo.findByLanguage(input.language, input.limit);
+    }
+    if (input.projectId) {
+      return this.codeModuleRepo.findByProject(input.projectId);
+    }
+    return [];
+  }
+
+  checkSimilarity(source: string, language: string): Array<{ moduleId: number; score: number; matchType: string }> {
+    const fingerprint = fingerprintCode(source, language);
+    const allModules = this.codeModuleRepo.findByLanguage(language);
+
+    const exact = findExactMatches(fingerprint, allModules);
+    if (exact.length > 0) return exact;
+
+    return findSemanticMatches(source, allModules, 0.5);
+  }
+
+  listModules(projectId?: number): CodeModuleRecord[] {
+    if (projectId) {
+      return this.codeModuleRepo.findByProject(projectId);
+    }
+    return [];
+  }
+
+  getById(id: number): CodeModuleRecord | undefined {
+    return this.codeModuleRepo.getById(id);
+  }
+}

package/src/services/error.service.ts

@@ -0,0 +1,164 @@
+import type { ErrorRecord } from '../types/error.types.js';
+import type { ErrorRepository } from '../db/repositories/error.repository.js';
+import type { ProjectRepository } from '../db/repositories/project.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import { parseError } from '../parsing/error-parser.js';
+import { generateFingerprint } from '../matching/fingerprint.js';
+import { matchError, type MatchResult } from '../matching/error-matcher.js';
+import { getEventBus } from '../utils/events.js';
+import { getLogger } from '../utils/logger.js';
+
+export interface ReportErrorInput {
+  project: string;
+  errorOutput: string;
+  filePath?: string;
+  terminalId?: number;
+}
+
+export interface ErrorQueryInput {
+  projectId?: number;
+  resolved?: boolean;
+  search?: string;
+  limit?: number;
+}
+
+export class ErrorService {
+  private logger = getLogger();
+  private eventBus = getEventBus();
+
+  constructor(
+    private errorRepo: ErrorRepository,
+    private projectRepo: ProjectRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  report(input: ReportErrorInput): { errorId: number; isNew: boolean; matches: MatchResult[] } {
+    // 1. Ensure project exists
+    let project = this.projectRepo.findByName(input.project);
+    if (!project) {
+      const id = this.projectRepo.create({ name: input.project, path: null, language: null, framework: null });
+      project = this.projectRepo.getById(id)!;
+    }
+
+    // 2. Parse the error
+    const parsed = parseError(input.errorOutput);
+    if (!parsed) {
+      this.logger.warn('Could not parse error output');
+      const errorId = this.errorRepo.create({
+        project_id: project.id,
+        terminal_id: input.terminalId ?? null,
+        fingerprint: '',
+        type: 'UnknownError',
+        message: input.errorOutput.split('\n')[0] ?? input.errorOutput,
+        raw_output: input.errorOutput,
+        context: null,
+        file_path: input.filePath ?? null,
+        line_number: null,
+        column_number: null,
+      });
+      return { errorId, isNew: true, matches: [] };
+    }
+
+    // 3. Generate fingerprint
+    const fingerprint = generateFingerprint(parsed.errorType, parsed.message, parsed.frames);
+
+    // 4. Check for existing error with same fingerprint
+    const existing = this.errorRepo.findByFingerprint(fingerprint);
+    if (existing.length > 0) {
+      const err = existing[0]!;
+      this.errorRepo.incrementOccurrence(err.id);
+      this.logger.info(`Known error (id=${err.id}), occurrence incremented`);
+
+      // Strengthen synapse
+      this.synapseManager.strengthen(
+        { type: 'error', id: err.id },
+        { type: 'project', id: project.id },
+        'co_occurs',
+      );
+
+      return { errorId: err.id, isNew: false, matches: [] };
+    }
+
+    // 5. Create new error record
+    const errorId = this.errorRepo.create({
+      project_id: project.id,
+      terminal_id: input.terminalId ?? null,
+      fingerprint,
+      type: parsed.errorType,
+      message: parsed.message,
+      raw_output: input.errorOutput,
+      context: null,
+      file_path: parsed.sourceFile ?? input.filePath ?? null,
+      line_number: parsed.sourceLine ?? null,
+      column_number: null,
+    });
+
+    // 6. Create synapse: error ↔ project
+    this.synapseManager.strengthen(
+      { type: 'error', id: errorId },
+      { type: 'project', id: project.id },
+      'co_occurs',
+    );
+
+    // 7. Find similar errors
+    const candidates = this.errorRepo.findByProject(project.id)
+      .filter(e => e.id !== errorId);
+    const newError = this.errorRepo.getById(errorId)!;
+    const matches = matchError(newError, candidates);
+
+    // 8. Create similarity synapses for strong matches
+    for (const match of matches.filter(m => m.isStrong)) {
+      this.synapseManager.strengthen(
+        { type: 'error', id: errorId },
+        { type: 'error', id: match.errorId },
+        'similar_to',
+      );
+    }
+
+    this.eventBus.emit('error:reported', { errorId, projectId: project.id, fingerprint });
+    this.logger.info(`New error reported (id=${errorId}, type=${parsed.errorType})`);
+
+    return { errorId, isNew: true, matches };
+  }
+
+  query(input: ErrorQueryInput): ErrorRecord[] {
+    if (input.search) {
+      return this.errorRepo.search(input.search);
+    }
+    if (input.resolved === false) {
+      return this.errorRepo.findUnresolved(input.projectId);
+    }
+    if (input.projectId) {
+      return this.errorRepo.findByProject(input.projectId);
+    }
+    return [];
+  }
+
+  matchSimilar(errorId: number): MatchResult[] {
+    const error = this.errorRepo.getById(errorId);
+    if (!error) return [];
+
+    const candidates = this.errorRepo.findByProject(error.project_id)
+      .filter(e => e.id !== errorId);
+    return matchError(error, candidates);
+  }
+
+  resolve(errorId: number, solutionId?: number): void {
+    this.errorRepo.update(errorId, {
+      resolved: 1,
+      resolved_at: new Date().toISOString(),
+    });
+
+    if (solutionId) {
+      this.eventBus.emit('error:resolved', { errorId, solutionId });
+    }
+  }
+
+  getById(id: number): ErrorRecord | undefined {
+    return this.errorRepo.getById(id);
+  }
+
+  countSince(since: string, projectId?: number): number {
+    return this.errorRepo.countSince(since, projectId);
+  }
+}

package/src/services/notification.service.ts

@@ -0,0 +1,41 @@
+import type { NotificationRepository, NotificationRecord } from '../db/repositories/notification.repository.js';
+import { getLogger } from '../utils/logger.js';
+
+export interface CreateNotificationInput {
+  type: string;
+  title: string;
+  message: string;
+  priority?: number;
+  projectId?: number;
+}
+
+export class NotificationService {
+  private logger = getLogger();
+
+  constructor(private notificationRepo: NotificationRepository) {}
+
+  create(input: CreateNotificationInput): number {
+    const id = this.notificationRepo.create({
+      type: input.type,
+      title: input.title,
+      message: input.message,
+      priority: input.priority ?? 0,
+      project_id: input.projectId ?? null,
+    });
+
+    this.logger.info(`Notification created (id=${id}, type=${input.type})`);
+    return id;
+  }
+
+  list(projectId?: number): NotificationRecord[] {
+    return this.notificationRepo.findUnacknowledged(projectId);
+  }
+
+  acknowledge(id: number): void {
+    this.notificationRepo.acknowledge(id);
+  }
+
+  getById(id: number): NotificationRecord | undefined {
+    return this.notificationRepo.getById(id);
+  }
+}