@timmeck/brain 1.0.0

package/tests/integration/synapse-flow.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createTestDb, type TestDb } from '../helpers/setup-db.js';
+import { SynapseManager } from '../../src/synapses/synapse-manager.js';
+import { SynapseService } from '../../src/services/synapse.service.js';
+
+const synapsesConfig = {
+  initialWeight: 0.1,
+  learningRate: 0.15,
+  decayHalfLifeDays: 45,
+  pruneThreshold: 0.05,
+  decayAfterDays: 14,
+  maxDepth: 3,
+  minActivationWeight: 0.2,
+};
+
+describe('Synapse Flow Integration', () => {
+  let testDb: TestDb;
+  let synapseManager: SynapseManager;
+  let synapseService: SynapseService;
+
+  beforeEach(() => {
+    testDb = createTestDb();
+    synapseManager = new SynapseManager(testDb.repos.synapse, synapsesConfig);
+    synapseService = new SynapseService(synapseManager);
+
+    // Create test data
+    testDb.repos.project.create({ name: 'test', path: '/test' } as any);
+    testDb.repos.error.create({
+      project_id: 1, terminal_id: null, fingerprint: 'fp1', type: 'TypeError',
+      message: 'error 1', raw_output: 'TypeError: 1', context: null,
+      file_path: null, line_number: null, column_number: null,
+    } as any);
+    testDb.repos.error.create({
+      project_id: 1, terminal_id: null, fingerprint: 'fp2', type: 'TypeError',
+      message: 'error 2', raw_output: 'TypeError: 2', context: null,
+      file_path: null, line_number: null, column_number: null,
+    } as any);
+    testDb.repos.error.create({
+      project_id: 1, terminal_id: null, fingerprint: 'fp3', type: 'TypeError',
+      message: 'error 3', raw_output: 'TypeError: 3', context: null,
+      file_path: null, line_number: null, column_number: null,
+    } as any);
+  });
+
+  it('builds and queries a synapse network', () => {
+    synapseManager.strengthen(
+      { type: 'error', id: 1 },
+      { type: 'error', id: 2 },
+      'similar_to',
+    );
+    synapseManager.strengthen(
+      { type: 'error', id: 1 },
+      { type: 'project', id: 1 },
+      'co_occurs',
+    );
+
+    const stats = synapseService.getNetworkStats();
+    expect(stats.totalSynapses).toBe(2);
+
+    const strongest = synapseService.getStrongestSynapses(10);
+    expect(strongest.length).toBe(2);
+  });
+
+  it('strengthening same synapse increases weight', () => {
+    const first = synapseManager.strengthen(
+      { type: 'error', id: 1 },
+      { type: 'error', id: 2 },
+      'similar_to',
+    );
+
+    const second = synapseManager.strengthen(
+      { type: 'error', id: 1 },
+      { type: 'error', id: 2 },
+      'similar_to',
+    );
+
+    expect(second.weight).toBeGreaterThan(first.weight);
+  });
+
+  it('finds path between connected nodes', () => {
+    synapseManager.strengthen(
+      { type: 'error', id: 1 },
+      { type: 'error', id: 2 },
+      'similar_to',
+    );
+    synapseManager.strengthen(
+      { type: 'error', id: 2 },
+      { type: 'error', id: 3 },
+      'similar_to',
+    );
+
+    const path = synapseService.findPath('error', 1, 'error', 3);
+    expect(path).not.toBeNull();
+    expect(path!.hops).toBe(2);
+  });
+
+  it('returns null for unconnected nodes', () => {
+    const path = synapseService.findPath('error', 1, 'error', 3);
+    expect(path).toBeNull();
+  });
+
+  it('decay reduces old synapse weights', () => {
+    synapseManager.strengthen(
+      { type: 'error', id: 1 },
+      { type: 'error', id: 2 },
+      'similar_to',
+    );
+
+    // Make synapse old
+    testDb.db.prepare(
+      `UPDATE synapses SET last_activated_at = datetime('now', '-100 days')`
+    ).run();
+
+    const { decayed, pruned } = synapseManager.runDecay();
+    expect(decayed + pruned).toBeGreaterThanOrEqual(0);
+  });
+});

package/tests/unit/code/analyzer.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { analyzeCode, checkPurity, measureCohesion } from '../../../src/code/analyzer.js';
+import { retryModule, loggerModule, hashModule } from '../../fixtures/code-modules/modules.js';
+
+describe('analyzeCode', () => {
+  it('analyzes TypeScript module', () => {
+    const result = analyzeCode(retryModule.source, 'typescript');
+    expect(result).toBeTruthy();
+    expect(result.exports).toBeDefined();
+    expect(result.linesOfCode).toBeGreaterThan(0);
+  });
+
+  it('analyzes Python module', () => {
+    const result = analyzeCode(hashModule.source, 'python');
+    expect(result).toBeTruthy();
+    expect(result.exports.length).toBeGreaterThan(0);
+  });
+
+  it('detects exports in TypeScript', () => {
+    const result = analyzeCode(retryModule.source, 'typescript');
+    const exportNames = result.exports.map((e: any) => e.name);
+    expect(exportNames).toContain('retry');
+  });
+
+  it('detects external dependencies', () => {
+    const result = analyzeCode(loggerModule.source, 'typescript');
+    expect(result.externalDeps.length).toBeGreaterThan(0);
+  });
+});
+
+describe('checkPurity', () => {
+  it('pure function returns true', () => {
+    const pureCode = `export function add(a: number, b: number): number { return a + b; }`;
+    expect(checkPurity(pureCode)).toBe(true);
+  });
+
+  it('function with side effects returns false', () => {
+    const impureCode = `export function save(data: any) { fs.writeFileSync('file', data); console.log('saved'); }`;
+    expect(checkPurity(impureCode)).toBe(false);
+  });
+});
+
+describe('measureCohesion', () => {
+  it('returns value between 0 and 1', () => {
+    const exports = [
+      { name: 'sha256', type: 'function' },
+      { name: 'md5', type: 'function' },
+    ] as any[];
+    const score = measureCohesion(exports);
+    expect(score).toBeGreaterThanOrEqual(0);
+    expect(score).toBeLessThanOrEqual(1);
+  });
+
+  it('handles empty exports without crashing', () => {
+    const score = measureCohesion([]);
+    expect(typeof score).toBe('number');
+  });
+});

package/tests/unit/code/fingerprint.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest';
+import { fingerprintCode, stripComments } from '../../../src/code/fingerprint.js';
+
+describe('fingerprintCode', () => {
+  it('produces consistent fingerprint', () => {
+    const code = 'function add(a, b) { return a + b; }';
+    const fp1 = fingerprintCode(code, 'typescript');
+    const fp2 = fingerprintCode(code, 'typescript');
+    expect(fp1).toBe(fp2);
+  });
+
+  it('produces different fingerprint for different code', () => {
+    const fp1 = fingerprintCode('function add(a, b) { return a + b; }', 'typescript');
+    const fp2 = fingerprintCode('function mul(a, b) { return a * b; }', 'typescript');
+    expect(fp1).not.toBe(fp2);
+  });
+
+  it('ignores whitespace differences', () => {
+    const fp1 = fingerprintCode('function add(a, b) { return a + b; }', 'typescript');
+    const fp2 = fingerprintCode('function add(a,  b) {\n  return a + b;\n}', 'typescript');
+    expect(fp1).toBe(fp2);
+  });
+
+  it('returns hex string', () => {
+    const fp = fingerprintCode('const x = 1;', 'typescript');
+    expect(fp).toMatch(/^[a-f0-9]+$/);
+  });
+});
+
+describe('stripComments', () => {
+  it('removes single-line comments', () => {
+    const code = 'const x = 1; // this is a comment\nconst y = 2;';
+    const stripped = stripComments(code, 'typescript');
+    expect(stripped).not.toContain('this is a comment');
+    expect(stripped).toContain('const x = 1');
+  });
+
+  it('removes multi-line comments', () => {
+    const code = '/* block comment */\nconst x = 1;';
+    const stripped = stripComments(code, 'typescript');
+    expect(stripped).not.toContain('block comment');
+    expect(stripped).toContain('const x = 1');
+  });
+
+  it('removes Python comments', () => {
+    const code = '# python comment\nx = 1';
+    const stripped = stripComments(code, 'python');
+    expect(stripped).not.toContain('python comment');
+    expect(stripped).toContain('x = 1');
+  });
+});

package/tests/unit/code/scorer.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { computeReusabilityScore, getSignalBreakdown, MODULE_THRESHOLD } from '../../../src/code/scorer.js';
+import { analyzeCode } from '../../../src/code/analyzer.js';
+import { retryModule } from '../../fixtures/code-modules/modules.js';
+
+describe('computeReusabilityScore', () => {
+  it('scores a real module', () => {
+    const analysis = analyzeCode(retryModule.source, 'typescript');
+    const score = computeReusabilityScore({
+      source: retryModule.source,
+      filePath: retryModule.filePath,
+      exports: analysis.exports,
+      internalDeps: analysis.internalDeps,
+      hasTypeAnnotations: analysis.hasTypeAnnotations,
+    });
+    expect(score).toBeGreaterThan(0);
+    expect(score).toBeLessThanOrEqual(1);
+  });
+
+  it('returns value between 0 and 1', () => {
+    const score = computeReusabilityScore({
+      source: 'export function add(a: number, b: number) { return a + b; }',
+      filePath: 'utils/add.ts',
+      exports: [{ name: 'add', type: 'function' }] as any[],
+      internalDeps: [],
+      hasTypeAnnotations: true,
+    });
+    expect(score).toBeGreaterThanOrEqual(0);
+    expect(score).toBeLessThanOrEqual(1);
+  });
+});
+
+describe('getSignalBreakdown', () => {
+  it('returns named signals with scores', () => {
+    const signals = getSignalBreakdown({
+      source: 'export function add(a: number, b: number) { return a + b; }',
+      filePath: 'utils/add.ts',
+      exports: [{ name: 'add', type: 'function' }] as any[],
+      internalDeps: [],
+      hasTypeAnnotations: true,
+    });
+    expect(signals.length).toBeGreaterThan(0);
+    for (const signal of signals) {
+      expect(signal.name).toBeTruthy();
+      expect(typeof signal.score).toBe('number');
+      expect(typeof signal.weighted).toBe('number');
+    }
+  });
+});
+
+describe('MODULE_THRESHOLD', () => {
+  it('is 0.6', () => {
+    expect(MODULE_THRESHOLD).toBe(0.6);
+  });
+});

package/tests/unit/learning/confidence-scorer.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { wilsonScore, timeDecayedConfidence, computeConfidence } from '../../../src/learning/confidence-scorer.js';
+
+describe('wilsonScore', () => {
+  it('returns 0 for 0 trials', () => {
+    expect(wilsonScore(0, 0)).toBe(0);
+  });
+
+  it('returns low score for single success', () => {
+    const score = wilsonScore(1, 1);
+    // 1/1 = 100% but Wilson should be conservative
+    expect(score).toBeLessThan(0.9);
+    expect(score).toBeGreaterThan(0);
+  });
+
+  it('increases with more samples', () => {
+    const score5 = wilsonScore(5, 5);
+    const score50 = wilsonScore(50, 50);
+    expect(score50).toBeGreaterThan(score5);
+  });
+
+  it('reflects success rate', () => {
+    const high = wilsonScore(9, 10);
+    const low = wilsonScore(1, 10);
+    expect(high).toBeGreaterThan(low);
+  });
+
+  it('returns value between 0 and 1', () => {
+    const score = wilsonScore(7, 10);
+    expect(score).toBeGreaterThanOrEqual(0);
+    expect(score).toBeLessThanOrEqual(1);
+  });
+});
+
+describe('timeDecayedConfidence', () => {
+  it('recent usage has higher confidence', () => {
+    const now = new Date().toISOString();
+    const recent = timeDecayedConfidence(8, 10, now, 30);
+
+    const oldDate = new Date(Date.now() - 90 * 86400000).toISOString();
+    const old = timeDecayedConfidence(8, 10, oldDate, 30);
+
+    expect(recent).toBeGreaterThan(old);
+  });
+});
+
+describe('computeConfidence', () => {
+  it('combines success rate and time decay', () => {
+    const now = new Date().toISOString();
+    const conf = computeConfidence(8, 2, now);
+    expect(conf).toBeGreaterThan(0);
+    expect(conf).toBeLessThanOrEqual(1);
+  });
+
+  it('zero successes gives low confidence', () => {
+    const now = new Date().toISOString();
+    const conf = computeConfidence(0, 5, now);
+    expect(conf).toBeLessThan(0.3);
+  });
+});

package/tests/unit/learning/decay.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { relevanceDecay, shouldPruneRule } from '../../../src/learning/decay.js';
+
+describe('relevanceDecay', () => {
+  it('returns 1.0 for current timestamp', () => {
+    const now = new Date().toISOString();
+    expect(relevanceDecay(now, 30)).toBeCloseTo(1.0, 1);
+  });
+
+  it('returns ~0.5 after one half-life', () => {
+    const halfLifeDays = 30;
+    const past = new Date(Date.now() - halfLifeDays * 86400000).toISOString();
+    expect(relevanceDecay(past, halfLifeDays)).toBeCloseTo(0.5, 1);
+  });
+
+  it('returns near 0 for very old timestamps', () => {
+    const veryOld = new Date(Date.now() - 365 * 86400000).toISOString();
+    expect(relevanceDecay(veryOld, 30)).toBeLessThan(0.01);
+  });
+
+  it('returns value between 0 and 1', () => {
+    const past = new Date(Date.now() - 10 * 86400000).toISOString();
+    const val = relevanceDecay(past, 30);
+    expect(val).toBeGreaterThanOrEqual(0);
+    expect(val).toBeLessThanOrEqual(1);
+  });
+});
+
+describe('shouldPruneRule', () => {
+  it('prunes low confidence rules', () => {
+    expect(shouldPruneRule(0.1, 0, 10, 0.2, 0.5)).toBe(true);
+  });
+
+  it('keeps high confidence rules', () => {
+    expect(shouldPruneRule(0.8, 1, 20, 0.2, 0.5)).toBe(false);
+  });
+
+  it('prunes rules with high rejection rate', () => {
+    expect(shouldPruneRule(0.5, 8, 10, 0.2, 0.5)).toBe(true);
+  });
+
+  it('keeps rules with low rejection rate', () => {
+    expect(shouldPruneRule(0.5, 1, 10, 0.2, 0.5)).toBe(false);
+  });
+});

package/tests/unit/learning/pattern-extractor.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { extractPatterns } from '../../../src/learning/pattern-extractor.js';
+import type { ErrorRecord } from '../../../src/types/error.types.js';
+
+function makeErrorRecord(overrides: Partial<ErrorRecord> = {}): ErrorRecord {
+  return {
+    id: 1,
+    project_id: 1,
+    terminal_id: null,
+    type: 'TypeError',
+    message: "Cannot read properties of undefined (reading 'map')",
+    fingerprint: 'fp1',
+    raw_output: '',
+    context: null,
+    file_path: '/app/main.ts',
+    line_number: null,
+    column_number: null,
+    occurrence_count: 1,
+    first_seen: new Date().toISOString(),
+    last_seen: new Date().toISOString(),
+    resolved: 0,
+    resolved_at: null,
+    ...overrides,
+  };
+}
+
+describe('extractPatterns', () => {
+  it('finds pattern from similar errors', () => {
+    const errors = [
+      makeErrorRecord({ id: 1, message: "Cannot read properties of undefined (reading 'map')", fingerprint: 'fp1' }),
+      makeErrorRecord({ id: 2, message: "Cannot read properties of undefined (reading 'filter')", fingerprint: 'fp2' }),
+      makeErrorRecord({ id: 3, message: "Cannot read properties of undefined (reading 'forEach')", fingerprint: 'fp3' }),
+      makeErrorRecord({ id: 4, message: "Cannot read properties of undefined (reading 'reduce')", fingerprint: 'fp4' }),
+    ];
+
+    const patterns = extractPatterns(errors);
+    expect(patterns.length).toBeGreaterThan(0);
+    expect(patterns[0].errorIds.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('returns empty for single error', () => {
+    const errors = [makeErrorRecord({ id: 1 })];
+    const patterns = extractPatterns(errors);
+    expect(patterns).toEqual([]);
+  });
+
+  it('returns empty for empty input', () => {
+    expect(extractPatterns([])).toEqual([]);
+  });
+});

package/tests/unit/matching/error-matcher.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest';
+import { matchError } from '../../../src/matching/error-matcher.js';
+import type { ErrorRecord } from '../../../src/types/error.types.js';
+
+function makeError(overrides: Partial<ErrorRecord> = {}): ErrorRecord {
+  return {
+    id: 1,
+    project_id: 1,
+    terminal_id: null,
+    type: 'TypeError',
+    message: "Cannot read properties of undefined (reading 'map')",
+    fingerprint: 'abc123',
+    raw_output: "TypeError: Cannot read properties of undefined (reading 'map')",
+    context: null,
+    file_path: '/app/src/main.ts',
+    line_number: null,
+    column_number: null,
+    occurrence_count: 1,
+    first_seen: new Date().toISOString(),
+    last_seen: new Date().toISOString(),
+    resolved: 0,
+    resolved_at: null,
+    ...overrides,
+  };
+}
+
+describe('matchError', () => {
+  it('returns matches sorted by score', () => {
+    const incoming = makeError({ id: 0 });
+    const candidates = [
+      makeError({ id: 1, fingerprint: 'abc123', type: 'TypeError' }),
+      makeError({ id: 2, fingerprint: 'different', type: 'RangeError', message: 'Maximum call stack size exceeded' }),
+    ];
+
+    const results = matchError(incoming, candidates);
+    expect(results.length).toBeGreaterThan(0);
+    // Identical fingerprint should score highest
+    expect(results[0].errorId).toBe(1);
+  });
+
+  it('returns empty for no candidates', () => {
+    const incoming = makeError({ id: 0 });
+    const results = matchError(incoming, []);
+    expect(results).toEqual([]);
+  });
+
+  it('fingerprint match boosts score', () => {
+    const incoming = makeError({ id: 0, fingerprint: 'same_fp' });
+    const exactFp = makeError({ id: 1, fingerprint: 'same_fp' });
+    const diffFp = makeError({ id: 2, fingerprint: 'other_fp', type: 'RangeError', message: 'completely different' });
+
+    const results = matchError(incoming, [exactFp, diffFp]);
+    if (results.length >= 2) {
+      expect(results[0].errorId).toBe(1);
+      expect(results[0].score).toBeGreaterThan(results[1].score);
+    }
+  });
+
+  it('results have score and signals', () => {
+    const incoming = makeError({ id: 0 });
+    const candidate = makeError({ id: 1 });
+    const results = matchError(incoming, [candidate]);
+    if (results.length > 0) {
+      expect(typeof results[0].score).toBe('number');
+      expect(results[0].signals.length).toBeGreaterThan(0);
+      expect(typeof results[0].isStrong).toBe('boolean');
+    }
+  });
+});

package/tests/unit/matching/fingerprint.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import { templateMessage, generateFingerprint } from '../../../src/matching/fingerprint.js';
+
+describe('templateMessage', () => {
+  it('replaces file paths with placeholder', () => {
+    const result = templateMessage('Error in /app/src/main.ts:42:5');
+    expect(result).not.toContain('/app/src/main.ts');
+    expect(result).toContain('<PATH>');
+  });
+
+  it('replaces hex addresses with <ADDR>', () => {
+    const result = templateMessage('at 0x7fff5fbff8c0');
+    expect(result).toContain('<ADDR>');
+  });
+
+  it('produces consistent output for similar messages', () => {
+    const a = templateMessage("Cannot read property 'name' of undefined at /foo/bar.js:10:5");
+    const b = templateMessage("Cannot read property 'name' of undefined at /baz/qux.js:20:3");
+    expect(a).toBe(b);
+  });
+
+  it('replaces URLs', () => {
+    // Unix path regex runs before URL regex, so URL domain/path part gets <PATH>
+    // Test that the URL string is at least transformed (not left as-is)
+    const result = templateMessage('Failed to fetch https://api.example.com/data');
+    expect(result).not.toContain('https://api.example.com/data');
+  });
+});
+
+describe('generateFingerprint', () => {
+  it('produces consistent hash for same error', () => {
+    const fp1 = generateFingerprint('TypeError', 'Cannot read undefined', []);
+    const fp2 = generateFingerprint('TypeError', 'Cannot read undefined', []);
+    expect(fp1).toBe(fp2);
+  });
+
+  it('produces different hash for different error types', () => {
+    const fp1 = generateFingerprint('TypeError', 'msg', []);
+    const fp2 = generateFingerprint('RangeError', 'msg', []);
+    expect(fp1).not.toBe(fp2);
+  });
+
+  it('returns a hex string', () => {
+    const fp = generateFingerprint('Error', 'test', []);
+    expect(fp).toMatch(/^[a-f0-9]+$/);
+  });
+});

package/tests/unit/matching/similarity.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import { levenshteinDistance, cosineSimilarity, jaccardSimilarity } from '../../../src/matching/similarity.js';
+
+describe('levenshteinDistance (normalized similarity)', () => {
+  it('returns 1 for identical strings', () => {
+    expect(levenshteinDistance('hello', 'hello')).toBeCloseTo(1.0);
+  });
+
+  it('returns 0 for completely different strings', () => {
+    expect(levenshteinDistance('', 'abc')).toBeCloseTo(0.0);
+    expect(levenshteinDistance('abc', '')).toBeCloseTo(0.0);
+  });
+
+  it('returns high similarity for single edit', () => {
+    // cat vs bat: 1 edit / 3 length = 0.33 distance → 0.67 similarity
+    expect(levenshteinDistance('cat', 'bat')).toBeCloseTo(1 - 1 / 3, 1);
+  });
+
+  it('returns value between 0 and 1', () => {
+    const sim = levenshteinDistance('kitten', 'sitting');
+    expect(sim).toBeGreaterThanOrEqual(0);
+    expect(sim).toBeLessThanOrEqual(1);
+  });
+});
+
+describe('cosineSimilarity', () => {
+  it('returns 1 for identical token arrays', () => {
+    expect(cosineSimilarity(['a', 'b', 'c'], ['a', 'b', 'c'])).toBeCloseTo(1.0);
+  });
+
+  it('returns 0 for disjoint token arrays', () => {
+    expect(cosineSimilarity(['a', 'b'], ['c', 'd'])).toBeCloseTo(0.0);
+  });
+
+  it('returns value between 0 and 1 for partial overlap', () => {
+    const sim = cosineSimilarity(['a', 'b', 'c'], ['b', 'c', 'd']);
+    expect(sim).toBeGreaterThan(0);
+    expect(sim).toBeLessThan(1);
+  });
+
+  it('handles empty arrays', () => {
+    expect(cosineSimilarity([], [])).toBe(0);
+    expect(cosineSimilarity(['a'], [])).toBe(0);
+  });
+});
+
+describe('jaccardSimilarity', () => {
+  it('returns 1 for identical sets', () => {
+    expect(jaccardSimilarity(['a', 'b'], ['a', 'b'])).toBeCloseTo(1.0);
+  });
+
+  it('returns 0 for disjoint sets', () => {
+    expect(jaccardSimilarity(['a', 'b'], ['c', 'd'])).toBeCloseTo(0.0);
+  });
+
+  it('computes correct ratio for partial overlap', () => {
+    // intersection {b} = 1, union {a,b,c} = 3
+    const sim = jaccardSimilarity(['a', 'b'], ['b', 'c']);
+    expect(sim).toBeCloseTo(1 / 3);
+  });
+
+  it('handles empty arrays', () => {
+    expect(jaccardSimilarity([], [])).toBe(0);
+  });
+});