@timmeck/brain 1.2.0 → 1.8.0

package/src/services/error.service.ts

@@ -2,6 +2,8 @@ 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 type { MatchingConfig } from '../types/config.types.js';
+import type { EmbeddingEngine } from '../embeddings/engine.js';
 import { parseError } from '../parsing/error-parser.js';
 import { generateFingerprint } from '../matching/fingerprint.js';
 import { matchError, type MatchResult } from '../matching/error-matcher.js';
@@ -13,6 +15,9 @@ export interface ReportErrorInput {
   errorOutput: string;
   filePath?: string;
   terminalId?: number;
+  taskContext?: string;
+  workingDirectory?: string;
+  command?: string;
 }
 
 export interface ErrorQueryInput {
@@ -25,14 +30,23 @@ export interface ErrorQueryInput {
 export class ErrorService {
   private logger = getLogger();
   private eventBus = getEventBus();
+  private matchingConfig: MatchingConfig | null = null;
+  private embeddingEngine: EmbeddingEngine | null = null;
 
   constructor(
     private errorRepo: ErrorRepository,
     private projectRepo: ProjectRepository,
     private synapseManager: SynapseManager,
-  ) {}
+    matchingConfig?: MatchingConfig,
+  ) {
+    this.matchingConfig = matchingConfig ?? null;
+  }
+
+  setEmbeddingEngine(engine: EmbeddingEngine): void {
+    this.embeddingEngine = engine;
+  }
 
-  report(input: ReportErrorInput): { errorId: number; isNew: boolean; matches: MatchResult[] } {
+  report(input: ReportErrorInput): { errorId: number; isNew: boolean; matches: MatchResult[]; crossProjectMatches?: MatchResult[] } {
     // 1. Ensure project exists
     let project = this.projectRepo.findByName(input.project);
     if (!project) {
@@ -40,7 +54,10 @@ export class ErrorService {
       project = this.projectRepo.getById(id)!;
     }
 
-    // 2. Parse the error
+    // 2. Build context from available information
+    const context = this.buildContext(input);
+
+    // 3. Parse the error
     const parsed = parseError(input.errorOutput);
     if (!parsed) {
       this.logger.warn('Could not parse error output');
@@ -51,7 +68,7 @@ export class ErrorService {
         type: 'UnknownError',
         message: input.errorOutput.split('\n')[0] ?? input.errorOutput,
         raw_output: input.errorOutput,
-        context: null,
+        context,
         file_path: input.filePath ?? null,
         line_number: null,
         column_number: null,
@@ -59,14 +76,18 @@ export class ErrorService {
       return { errorId, isNew: true, matches: [] };
     }
 
-    // 3. Generate fingerprint
+    // 4. Generate fingerprint
     const fingerprint = generateFingerprint(parsed.errorType, parsed.message, parsed.frames);
 
-    // 4. Check for existing error with same fingerprint
+    // 5. 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);
+      // Update context if previously null
+      if (!err.context && context) {
+        this.errorRepo.update(err.id, { context });
+      }
       this.logger.info(`Known error (id=${err.id}), occurrence incremented`);
 
       // Strengthen synapse
@@ -79,7 +100,7 @@ export class ErrorService {
       return { errorId: err.id, isNew: false, matches: [] };
     }
 
-    // 5. Create new error record
+    // 6. Create new error record
     const errorId = this.errorRepo.create({
       project_id: project.id,
       terminal_id: input.terminalId ?? null,
@@ -87,26 +108,26 @@ export class ErrorService {
       type: parsed.errorType,
       message: parsed.message,
       raw_output: input.errorOutput,
-      context: null,
+      context,
       file_path: parsed.sourceFile ?? input.filePath ?? null,
       line_number: parsed.sourceLine ?? null,
       column_number: null,
     });
 
-    // 6. Create synapse: error ↔ project
+    // 7. Create synapse: error ↔ project
     this.synapseManager.strengthen(
       { type: 'error', id: errorId },
       { type: 'project', id: project.id },
       'co_occurs',
     );
 
-    // 7. Find similar errors
+    // 8. 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
+    // 9. Create similarity synapses for strong matches
     for (const match of matches.filter(m => m.isStrong)) {
       this.synapseManager.strengthen(
         { type: 'error', id: errorId },
@@ -115,10 +136,26 @@ export class ErrorService {
       );
     }
 
+    // 10. Error Chain Detection: link to recent unresolved errors in same project
+    this.detectErrorChain(errorId, project.id);
+
+    // 11. Cross-Project Transfer Learning
+    let crossProjectMatches: MatchResult[] = [];
+    if (this.matchingConfig?.crossProjectMatching) {
+      crossProjectMatches = this.findCrossProjectMatches(newError, project.id);
+      for (const match of crossProjectMatches.filter(m => m.isStrong)) {
+        this.synapseManager.strengthen(
+          { type: 'error', id: errorId },
+          { type: 'error', id: match.errorId },
+          'cross_project',
+        );
+      }
+    }
+
     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 };
+    return { errorId, isNew: true, matches, crossProjectMatches };
   }
 
   query(input: ErrorQueryInput): ErrorRecord[] {
@@ -140,7 +177,13 @@ export class ErrorService {
 
     const candidates = this.errorRepo.findByProject(error.project_id)
       .filter(e => e.id !== errorId);
-    return matchError(error, candidates);
+
+    // Hybrid search: include vector scores if embedding engine is available
+    const vectorScores = this.embeddingEngine?.isReady()
+      ? this.embeddingEngine.computeErrorVectorScores(errorId, error.project_id)
+      : undefined;
+
+    return matchError(error, candidates, vectorScores);
   }
 
   resolve(errorId: number, solutionId?: number): void {
@@ -161,4 +204,62 @@ export class ErrorService {
   countSince(since: string, projectId?: number): number {
     return this.errorRepo.countSince(since, projectId);
   }
+
+  getErrorChain(errorId: number): { parents: ErrorRecord[]; children: ErrorRecord[] } {
+    return {
+      parents: this.errorRepo.findChainParents(errorId),
+      children: this.errorRepo.findChainChildren(errorId),
+    };
+  }
+
+  private findCrossProjectMatches(error: ErrorRecord, currentProjectId: number): MatchResult[] {
+    const allProjects = this.projectRepo.getAll();
+    const otherProjects = allProjects.filter(p => p.id !== currentProjectId);
+    const weight = this.matchingConfig?.crossProjectWeight ?? 0.7;
+
+    const allMatches: MatchResult[] = [];
+    for (const project of otherProjects) {
+      const candidates = this.errorRepo.findByProject(project.id)
+        .filter(e => e.resolved === 1); // Only look at resolved errors from other projects
+      const matches = matchError(error, candidates);
+      // Apply cross-project weight discount
+      for (const match of matches) {
+        match.score *= weight;
+        match.isStrong = match.score >= 0.90;
+        allMatches.push(match);
+      }
+    }
+
+    return allMatches.sort((a, b) => b.score - a.score).slice(0, 5);
+  }
+
+  private detectErrorChain(newErrorId: number, projectId: number): void {
+    // Look for recent unresolved errors in the same project (last 10 minutes)
+    const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000).toISOString();
+    const recentErrors = this.errorRepo.findRecentByProject(projectId, tenMinutesAgo, 5);
+
+    for (const recent of recentErrors) {
+      if (recent.id === newErrorId) continue;
+      if (recent.resolved === 0) {
+        // This new error appeared while trying to fix a recent error → chain
+        this.errorRepo.createChain(recent.id, newErrorId, 'caused_by_fix');
+        this.synapseManager.strengthen(
+          { type: 'error', id: recent.id },
+          { type: 'error', id: newErrorId },
+          'causes',
+        );
+        this.logger.info(`Error chain: #${recent.id} → #${newErrorId} (caused_by_fix)`);
+        break; // Link to most recent parent only
+      }
+    }
+  }
+
+  private buildContext(input: ReportErrorInput): string | null {
+    const parts: string[] = [];
+    if (input.taskContext) parts.push(`task: ${input.taskContext}`);
+    if (input.command) parts.push(`command: ${input.command}`);
+    if (input.workingDirectory) parts.push(`cwd: ${input.workingDirectory}`);
+    if (input.filePath) parts.push(`file: ${input.filePath}`);
+    return parts.length > 0 ? parts.join(' | ') : null;
+  }
 }

package/src/services/git.service.ts

@@ -0,0 +1,132 @@
+import { execSync } from 'node:child_process';
+import type Database from 'better-sqlite3';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import { getLogger } from '../utils/logger.js';
+
+export interface GitCommitInfo {
+  hash: string;
+  message: string;
+  author: string;
+  timestamp: string;
+  filesChanged: number;
+  insertions: number;
+  deletions: number;
+}
+
+export class GitService {
+  private logger = getLogger();
+
+  constructor(
+    private db: Database.Database,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  /**
+   * Get current git info for context enrichment
+   */
+  getGitContext(cwd?: string): { branch: string | null; diff: string | null; lastCommit: string | null } {
+    try {
+      const opts = cwd ? { cwd, timeout: 5000 } : { timeout: 5000 };
+      const branch = execSync('git rev-parse --abbrev-ref HEAD', { ...opts, encoding: 'utf8' }).trim();
+      const diff = execSync('git diff --stat HEAD', { ...opts, encoding: 'utf8' }).trim();
+      const lastCommit = execSync('git log -1 --pretty=format:"%H %s"', { ...opts, encoding: 'utf8' }).trim();
+      return { branch, diff: diff || null, lastCommit };
+    } catch {
+      return { branch: null, diff: null, lastCommit: null };
+    }
+  }
+
+  /**
+   * Store a git commit and link it to an error
+   */
+  linkErrorToCommit(errorId: number, projectId: number, commitHash: string, relationship: string = 'introduced_by'): void {
+    try {
+      // Store commit info
+      const commitInfo = this.getCommitInfo(commitHash);
+      if (commitInfo) {
+        this.db.prepare(`
+          INSERT OR IGNORE INTO git_commits (project_id, commit_hash, message, author, timestamp, files_changed, insertions, deletions)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(projectId, commitInfo.hash, commitInfo.message, commitInfo.author, commitInfo.timestamp,
+          commitInfo.filesChanged, commitInfo.insertions, commitInfo.deletions);
+      }
+
+      // Link error to commit
+      this.db.prepare(`
+        INSERT OR IGNORE INTO error_commits (error_id, commit_hash, relationship)
+        VALUES (?, ?, ?)
+      `).run(errorId, commitHash, relationship);
+
+      this.logger.info(`Linked error #${errorId} to commit ${commitHash.slice(0, 8)} (${relationship})`);
+    } catch (err) {
+      this.logger.warn(`Failed to link error to commit: ${err}`);
+    }
+  }
+
+  /**
+   * Find which commit introduced an error
+   */
+  findIntroducingCommit(errorId: number): Array<{ commitHash: string; message: string; relationship: string }> {
+    const rows = this.db.prepare(`
+      SELECT ec.commit_hash, ec.relationship, gc.message
+      FROM error_commits ec
+      LEFT JOIN git_commits gc ON ec.commit_hash = gc.commit_hash
+      WHERE ec.error_id = ?
+      ORDER BY ec.created_at DESC
+    `).all(errorId) as Array<{ commit_hash: string; message: string | null; relationship: string }>;
+
+    return rows.map(r => ({
+      commitHash: r.commit_hash,
+      message: r.message ?? 'unknown',
+      relationship: r.relationship,
+    }));
+  }
+
+  /**
+   * Find errors introduced by a specific commit
+   */
+  findErrorsByCommit(commitHash: string): Array<{ errorId: number; relationship: string }> {
+    const rows = this.db.prepare(`
+      SELECT error_id, relationship FROM error_commits WHERE commit_hash = ?
+    `).all(commitHash) as Array<{ error_id: number; relationship: string }>;
+
+    return rows.map(r => ({ errorId: r.error_id, relationship: r.relationship }));
+  }
+
+  /**
+   * Capture current git diff for error context
+   */
+  captureDiff(cwd?: string): string | null {
+    try {
+      const opts = cwd ? { cwd, timeout: 5000, encoding: 'utf8' as const } : { timeout: 5000, encoding: 'utf8' as const };
+      const diff = execSync('git diff HEAD --no-color', opts).trim();
+      // Truncate to avoid huge diffs
+      return diff.length > 5000 ? diff.slice(0, 5000) + '\n... (truncated)' : diff || null;
+    } catch {
+      return null;
+    }
+  }
+
+  private getCommitInfo(hash: string, cwd?: string): GitCommitInfo | null {
+    try {
+      const opts = cwd ? { cwd, timeout: 5000, encoding: 'utf8' as const } : { timeout: 5000, encoding: 'utf8' as const };
+      const info = execSync(`git log -1 --pretty=format:"%H|||%s|||%an|||%aI" ${hash}`, opts).trim();
+      const [commitHash, message, author, timestamp] = info.split('|||');
+
+      const stat = execSync(`git diff --stat ${hash}~1..${hash}`, opts).trim();
+      const statMatch = stat.match(/(\d+) files? changed(?:, (\d+) insertions?\(\+\))?(?:, (\d+) deletions?\(-\))?/);
+
+      return {
+        hash: commitHash ?? hash,
+        message: message ?? '',
+        author: author ?? '',
+        timestamp: timestamp ?? new Date().toISOString(),
+        filesChanged: parseInt(statMatch?.[1] ?? '0', 10),
+        insertions: parseInt(statMatch?.[2] ?? '0', 10),
+        deletions: parseInt(statMatch?.[3] ?? '0', 10),
+      };
+    } catch {
+      return null;
+    }
+  }
+}

package/src/services/prevention.service.ts

@@ -105,6 +105,46 @@ export class PreventionService {
     });
   }
 
+  checkCodeForPatterns(source: string, filePath?: string): { warnings: Array<{ message: string; severity: string; ruleId?: number }> } {
+    const warnings: Array<{ message: string; severity: string; ruleId?: number }> = [];
+
+    // Check antipatterns against the code itself
+    const globalAntipatterns = this.antipatternRepo.findGlobal();
+    for (const ap of globalAntipatterns) {
+      try {
+        const pattern = new RegExp(ap.pattern, 'i');
+        if (pattern.test(source)) {
+          warnings.push({
+            message: `Code matches known error pattern: ${ap.description}${ap.suggestion ? `. Suggestion: ${ap.suggestion}` : ''}`,
+            severity: ap.severity,
+            ruleId: undefined,
+          });
+        }
+      } catch {
+        // Invalid regex, skip
+      }
+    }
+
+    // Check active rules
+    const rules = this.ruleRepo.findActive();
+    for (const rule of rules) {
+      try {
+        const pattern = new RegExp(rule.pattern, 'i');
+        if (pattern.test(source)) {
+          warnings.push({
+            message: `Code matches learned rule: ${rule.description ?? rule.pattern}. Action: ${rule.action}`,
+            severity: 'warning',
+            ruleId: rule.id,
+          });
+        }
+      } catch {
+        // Invalid regex, skip
+      }
+    }
+
+    return { warnings: warnings.slice(0, 5) };
+  }
+
   reportPrevention(ruleId: number, errorId: number): void {
     const rule = this.ruleRepo.getById(ruleId);
     if (rule) {

package/src/services/research.service.ts

@@ -90,4 +90,9 @@ export class ResearchService {
   expireOldInsights(): number {
     return this.insightRepo.expire();
   }
+
+  rateInsight(id: number, rating: number, comment?: string): boolean {
+    const clamped = Math.max(-1, Math.min(1, rating)); // -1 (bad), 0 (neutral), 1 (useful)
+    return this.insightRepo.rate(id, clamped, comment);
+  }
 }

package/src/services/solution.service.ts

@@ -113,4 +113,62 @@ export class SolutionService {
   successRate(solutionId: number): number {
     return this.solutionRepo.successRate(solutionId);
   }
+
+  analyzeEfficiency(): {
+    avgDurationMs: number;
+    slowSolutions: Array<{ solutionId: number; avgDuration: number; description: string }>;
+    successRateOverall: number;
+    totalAttempts: number;
+  } {
+    const allSolutions = this.solutionRepo.getAll();
+    let totalDuration = 0;
+    let totalAttempts = 0;
+    let totalSuccessRate = 0;
+    let solutionCount = 0;
+    const solutionDurations: Array<{ solutionId: number; avgDuration: number; description: string }> = [];
+
+    for (const solution of allSolutions) {
+      const rate = this.solutionRepo.successRate(solution.id);
+      if (solution.success_count + solution.fail_count > 0) {
+        totalSuccessRate += rate;
+        solutionCount++;
+      }
+
+      // Check attempts for duration data
+      const attempts = this.solutionRepo.getAttempts(solution.id);
+      if (attempts.length > 0) {
+        let solDuration = 0;
+        let solAttemptCount = 0;
+        for (const attempt of attempts) {
+          if (attempt.duration_ms && attempt.duration_ms > 0) {
+            solDuration += attempt.duration_ms;
+            solAttemptCount++;
+            totalDuration += attempt.duration_ms;
+            totalAttempts++;
+          }
+        }
+        if (solAttemptCount > 0) {
+          solutionDurations.push({
+            solutionId: solution.id,
+            avgDuration: solDuration / solAttemptCount,
+            description: solution.description,
+          });
+        }
+      }
+    }
+
+    // Find slow solutions (above 2x average)
+    const avgDurationMs = totalAttempts > 0 ? totalDuration / totalAttempts : 0;
+    const slowSolutions = solutionDurations
+      .filter(s => s.avgDuration > avgDurationMs * 2)
+      .sort((a, b) => b.avgDuration - a.avgDuration)
+      .slice(0, 10);
+
+    return {
+      avgDurationMs,
+      slowSolutions,
+      successRateOverall: solutionCount > 0 ? totalSuccessRate / solutionCount : 0,
+      totalAttempts,
+    };
+  }
 }

package/src/types/config.types.ts

@@ -22,6 +22,8 @@ export interface MatchingConfig {
   fingerprintFields: string[];
   similarityThreshold: number;
   maxResults: number;
+  crossProjectMatching: boolean;
+  crossProjectWeight: number;
 }
 
 export interface CodeConfig {
@@ -64,10 +66,32 @@ export interface RetentionConfig {
   insightDays: number;
 }
 
+export interface ApiConfig {
+  port: number;
+  enabled: boolean;
+  apiKey?: string;
+}
+
+export interface McpHttpConfig {
+  port: number;
+  enabled: boolean;
+}
+
+export interface EmbeddingsConfig {
+  enabled: boolean;
+  modelName: string;
+  cacheDir: string;
+  sweepIntervalMs: number;
+  batchSize: number;
+}
+
 export interface BrainConfig {
   dataDir: string;
   dbPath: string;
   ipc: IpcConfig;
+  api: ApiConfig;
+  mcpHttp: McpHttpConfig;
+  embeddings: EmbeddingsConfig;
   learning: LearningConfig;
   terminal: TerminalConfig;
   matching: MatchingConfig;

package/src/types/synapse.types.ts

@@ -5,6 +5,7 @@ export type SynapseType =
   | 'causes'
   | 'similar_to'
   | 'uses_module'
+  | 'depends_on'
   | 'derived_from'
   | 'co_occurs'
   | 'prevents'