@timmeck/brain 1.9.0 → 2.0.0

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

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

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

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

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

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

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

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

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

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

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

@@ -1,71 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { TfIdfIndex } from '../../../src/matching/tfidf.js';
-
-describe('TfIdfIndex', () => {
-  it('indexes documents and returns matches', () => {
-    const index = new TfIdfIndex();
-    // Add docs in order where query terms get correct IDF
-    // IDF is only recomputed for terms in the newly added doc,
-    // so add the doc with query terms last to ensure fresh IDF
-    index.addDocument(3, ['rust', 'borrow', 'lifetime']);
-    index.addDocument(2, ['python', 'import', 'module']);
-    index.addDocument(1, ['typescript', 'error', 'module']);
-
-    const results = index.query(['typescript']);
-    expect(results.length).toBeGreaterThan(0);
-    // Doc 1 has 'typescript'
-    expect(results[0].id).toBe(1);
-  });
-
-  it('tracks document count', () => {
-    const index = new TfIdfIndex();
-    expect(index.getDocumentCount()).toBe(0);
-    index.addDocument(1, ['a', 'b']);
-    expect(index.getDocumentCount()).toBe(1);
-    index.addDocument(2, ['c', 'd']);
-    expect(index.getDocumentCount()).toBe(2);
-  });
-
-  it('removes documents', () => {
-    const index = new TfIdfIndex();
-    index.addDocument(1, ['error', 'type']);
-    index.addDocument(2, ['error', 'syntax']);
-    index.removeDocument(1);
-    expect(index.getDocumentCount()).toBe(1);
-  });
-
-  it('returns empty for no match', () => {
-    const index = new TfIdfIndex();
-    index.addDocument(1, ['foo', 'bar']);
-    const results = index.query(['completely', 'different']);
-    expect(results).toEqual([]);
-  });
-
-  it('respects topK parameter', () => {
-    const index = new TfIdfIndex();
-    for (let i = 0; i < 20; i++) {
-      index.addDocument(i, ['shared', `unique${i}`]);
-    }
-    // 'unique0' only in doc 0, so has high IDF — query with it plus 'shared'
-    const results = index.query(['unique0', 'shared'], 5);
-    expect(results.length).toBeLessThanOrEqual(5);
-  });
-
-  it('getIdf returns a map', () => {
-    const index = new TfIdfIndex();
-    // IDF = log(N/df), only recomputed for terms in the just-added doc.
-    // Add 'frequent' in all 3 docs, 'rare' in last doc only.
-    // When doc3 is added (N=3), 'rare' df=1 → IDF=log(3)=1.099
-    // 'frequent' df=3 → IDF=log(3/3)=0
-    index.addDocument(1, ['frequent', 'alpha']);
-    index.addDocument(2, ['frequent', 'beta']);
-    index.addDocument(3, ['frequent', 'rare']);
-
-    const idf = index.getIdf();
-    expect(idf).toBeInstanceOf(Map);
-    expect(idf.has('rare')).toBe(true);
-    expect(idf.has('frequent')).toBe(true);
-    // rare appears in 1/3 docs, frequent in 3/3
-    expect(idf.get('rare')!).toBeGreaterThan(idf.get('frequent')!);
-  });
-});

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

@@ -1,83 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { splitCamelCase, splitSnakeCase, removeStopwords, tokenize } from '../../../src/matching/tokenizer.js';
-
-describe('splitCamelCase', () => {
-  it('splits camelCase words (preserves case)', () => {
-    const result = splitCamelCase('camelCase');
-    expect(result).toContain('camel');
-    expect(result).toContain('Case');
-  });
-
-  it('splits PascalCase words', () => {
-    const result = splitCamelCase('PascalCase');
-    expect(result).toContain('Pascal');
-    expect(result).toContain('Case');
-  });
-
-  it('handles consecutive uppercase (acronyms)', () => {
-    const result = splitCamelCase('parseHTMLResponse');
-    expect(result).toContain('parse');
-    expect(result).toContain('HTML');
-    expect(result).toContain('Response');
-  });
-
-  it('returns single word unchanged', () => {
-    expect(splitCamelCase('hello')).toEqual(['hello']);
-  });
-});
-
-describe('splitSnakeCase', () => {
-  it('splits snake_case words', () => {
-    expect(splitSnakeCase('snake_case')).toEqual(['snake', 'case']);
-  });
-
-  it('splits kebab-case words', () => {
-    expect(splitSnakeCase('kebab-case')).toEqual(['kebab', 'case']);
-  });
-
-  it('returns single word unchanged', () => {
-    expect(splitSnakeCase('hello')).toEqual(['hello']);
-  });
-});
-
-describe('removeStopwords', () => {
-  it('removes common stopwords', () => {
-    const tokens = ['the', 'is', 'in', 'module'];
-    const result = removeStopwords(tokens);
-    expect(result).toContain('module');
-    expect(result).not.toContain('the');
-    expect(result).not.toContain('is');
-  });
-
-  it('error is treated as stopword', () => {
-    // 'error' is in the stopword list
-    const tokens = ['error', 'module'];
-    const result = removeStopwords(tokens);
-    expect(result).toContain('module');
-  });
-});
-
-describe('tokenize', () => {
-  it('tokenizes and lowercases text', () => {
-    const tokens = tokenize('Cannot read property map of undefined');
-    expect(tokens).toContain('read');
-    expect(tokens).toContain('property');
-    expect(tokens).toContain('map');
-    expect(tokens).toContain('undefined');
-  });
-
-  it('handles empty string', () => {
-    expect(tokenize('')).toEqual([]);
-  });
-
-  it('lowercases all tokens', () => {
-    const tokens = tokenize('Something FAILED');
-    tokens.forEach(t => expect(t).toBe(t.toLowerCase()));
-  });
-
-  it('returns unique tokens', () => {
-    const tokens = tokenize('error error error');
-    const unique = new Set(tokens);
-    expect(tokens.length).toBe(unique.size);
-  });
-});