@timmeck/brain 1.8.0 → 1.8.2

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

@@ -1,65 +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);
-  });
-});
+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 +1,71 @@
-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')!);
-  });
-});
+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 +1,83 @@
-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);
-  });
-});
+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);
+  });
+});