@bendyline/squisq 0.1.2 → 1.1.0

package/src/__tests__/contentContainer.test.ts

@@ -0,0 +1,282 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { MemoryContentContainer, findDocumentPath } from '../storage/ContentContainer';
+import { createMediaProviderFromContainer } from '../storage/MediaProviderFromContainer';
+import type { ContentEntry } from '../storage/ContentContainer';
+
+// ============================================
+// MemoryContentContainer
+// ============================================
+
+describe('MemoryContentContainer', () => {
+  let container: MemoryContentContainer;
+
+  beforeEach(() => {
+    container = new MemoryContentContainer();
+  });
+
+  it('readFile returns null for missing file', async () => {
+    expect(await container.readFile('missing.txt')).toBeNull();
+  });
+
+  it('writeFile and readFile round-trip', async () => {
+    const data = new TextEncoder().encode('hello world');
+    await container.writeFile('test.txt', data, 'text/plain');
+    const result = await container.readFile('test.txt');
+    expect(result).not.toBeNull();
+    expect(new TextDecoder().decode(result!)).toBe('hello world');
+  });
+
+  it('writeFile with ArrayBuffer', async () => {
+    const buf = new ArrayBuffer(4);
+    new Uint8Array(buf).set([1, 2, 3, 4]);
+    await container.writeFile('data.bin', buf);
+    const result = await container.readFile('data.bin');
+    expect(new Uint8Array(result!)).toEqual(new Uint8Array([1, 2, 3, 4]));
+  });
+
+  it('writeFile overwrites existing file', async () => {
+    await container.writeFile('f.txt', new TextEncoder().encode('first'));
+    await container.writeFile('f.txt', new TextEncoder().encode('second'));
+    const result = await container.readFile('f.txt');
+    expect(new TextDecoder().decode(result!)).toBe('second');
+  });
+
+  it('removeFile deletes a file', async () => {
+    await container.writeFile('f.txt', new TextEncoder().encode('data'));
+    await container.removeFile('f.txt');
+    expect(await container.readFile('f.txt')).toBeNull();
+  });
+
+  it('removeFile is a no-op for missing file', async () => {
+    // Should not throw
+    await container.removeFile('nonexistent.txt');
+  });
+
+  it('exists returns true for existing file', async () => {
+    await container.writeFile('f.txt', new TextEncoder().encode('data'));
+    expect(await container.exists('f.txt')).toBe(true);
+  });
+
+  it('exists returns false for missing file', async () => {
+    expect(await container.exists('missing.txt')).toBe(false);
+  });
+
+  it('listFiles returns all files', async () => {
+    await container.writeFile('a.txt', new TextEncoder().encode('a'), 'text/plain');
+    await container.writeFile('b.jpg', new Uint8Array([0xff, 0xd8]), 'image/jpeg');
+    const entries = await container.listFiles();
+    expect(entries).toHaveLength(2);
+    expect(entries.map((e) => e.path).sort()).toEqual(['a.txt', 'b.jpg']);
+  });
+
+  it('listFiles with prefix filters results', async () => {
+    await container.writeFile('index.md', new TextEncoder().encode('# Hi'));
+    await container.writeFile('images/hero.jpg', new Uint8Array([0xff]));
+    await container.writeFile('images/bg.png', new Uint8Array([0x89]));
+    await container.writeFile('audio/clip.mp3', new Uint8Array([0x49]));
+
+    const imageEntries = await container.listFiles('images/');
+    expect(imageEntries).toHaveLength(2);
+    expect(imageEntries.map((e) => e.path).sort()).toEqual(['images/bg.png', 'images/hero.jpg']);
+  });
+
+  it('listFiles reports correct size', async () => {
+    const data = new Uint8Array([1, 2, 3, 4, 5]);
+    await container.writeFile('data.bin', data);
+    const entries = await container.listFiles();
+    expect(entries[0].size).toBe(5);
+  });
+
+  it('listFiles guesses MIME type from extension', async () => {
+    await container.writeFile('photo.jpg', new Uint8Array([0xff]));
+    const entries = await container.listFiles();
+    expect(entries[0].mimeType).toBe('image/jpeg');
+  });
+
+  it('listFiles uses provided MIME type over guess', async () => {
+    await container.writeFile('data.bin', new Uint8Array([0]), 'application/custom');
+    const entries = await container.listFiles();
+    expect(entries[0].mimeType).toBe('application/custom');
+  });
+});
+
+// ============================================
+// Document discovery
+// ============================================
+
+describe('getDocumentPath', () => {
+  let container: MemoryContentContainer;
+
+  beforeEach(() => {
+    container = new MemoryContentContainer();
+  });
+
+  it('returns null for empty container', async () => {
+    expect(await container.getDocumentPath()).toBeNull();
+  });
+
+  it('finds index.md', async () => {
+    await container.writeFile('index.md', new TextEncoder().encode('# Hello'));
+    expect(await container.getDocumentPath()).toBe('index.md');
+  });
+
+  it('prefers index.md over doc.md', async () => {
+    await container.writeFile('doc.md', new TextEncoder().encode('doc'));
+    await container.writeFile('index.md', new TextEncoder().encode('index'));
+    expect(await container.getDocumentPath()).toBe('index.md');
+  });
+
+  it('prefers doc.md over document.md', async () => {
+    await container.writeFile('document.md', new TextEncoder().encode('document'));
+    await container.writeFile('doc.md', new TextEncoder().encode('doc'));
+    expect(await container.getDocumentPath()).toBe('doc.md');
+  });
+
+  it('prefers document.md over arbitrary .md', async () => {
+    await container.writeFile('readme.md', new TextEncoder().encode('readme'));
+    await container.writeFile('document.md', new TextEncoder().encode('document'));
+    expect(await container.getDocumentPath()).toBe('document.md');
+  });
+
+  it('falls back to first .md at root', async () => {
+    await container.writeFile('my-story.md', new TextEncoder().encode('story'));
+    expect(await container.getDocumentPath()).toBe('my-story.md');
+  });
+
+  it('ignores .md files in subdirectories', async () => {
+    await container.writeFile('docs/notes.md', new TextEncoder().encode('notes'));
+    expect(await container.getDocumentPath()).toBeNull();
+  });
+
+  it('ignores non-md files', async () => {
+    await container.writeFile('data.json', new TextEncoder().encode('{}'));
+    await container.writeFile('hero.jpg', new Uint8Array([0xff]));
+    expect(await container.getDocumentPath()).toBeNull();
+  });
+});
+
+describe('readDocument / writeDocument', () => {
+  let container: MemoryContentContainer;
+
+  beforeEach(() => {
+    container = new MemoryContentContainer();
+  });
+
+  it('writeDocument creates index.md by default', async () => {
+    await container.writeDocument('# Hello');
+    expect(await container.getDocumentPath()).toBe('index.md');
+    expect(await container.readDocument()).toBe('# Hello');
+  });
+
+  it('writeDocument uses custom filename', async () => {
+    await container.writeDocument('# Custom', 'story.md');
+    expect(await container.getDocumentPath()).toBe('story.md');
+    expect(await container.readDocument()).toBe('# Custom');
+  });
+
+  it('readDocument returns null for empty container', async () => {
+    expect(await container.readDocument()).toBeNull();
+  });
+});
+
+// ============================================
+// findDocumentPath (standalone)
+// ============================================
+
+describe('findDocumentPath', () => {
+  it('returns null for empty list', () => {
+    expect(findDocumentPath([])).toBeNull();
+  });
+
+  it('finds index.md from entry list', () => {
+    const entries: ContentEntry[] = [
+      { path: 'images/hero.jpg', mimeType: 'image/jpeg', size: 100 },
+      { path: 'index.md', mimeType: 'text/markdown', size: 50 },
+    ];
+    expect(findDocumentPath(entries)).toBe('index.md');
+  });
+
+  it('skips subdirectory .md files', () => {
+    const entries: ContentEntry[] = [
+      { path: 'docs/guide.md', mimeType: 'text/markdown', size: 50 },
+    ];
+    expect(findDocumentPath(entries)).toBeNull();
+  });
+});
+
+// ============================================
+// createMediaProviderFromContainer
+// ============================================
+
+describe('createMediaProviderFromContainer', () => {
+  let container: MemoryContentContainer;
+  let blobCounter = 0;
+
+  beforeEach(() => {
+    container = new MemoryContentContainer();
+    blobCounter = 0;
+    // Mock URL.createObjectURL / revokeObjectURL (not available in Node)
+    vi.stubGlobal('URL', {
+      ...URL,
+      createObjectURL: () => `blob:mock-${++blobCounter}`,
+      revokeObjectURL: vi.fn(),
+    });
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('resolveUrl returns path as-is for missing file', async () => {
+    const provider = createMediaProviderFromContainer(container);
+    expect(await provider.resolveUrl('missing.jpg')).toBe('missing.jpg');
+    provider.dispose();
+  });
+
+  it('resolveUrl returns blob URL for existing file', async () => {
+    await container.writeFile('hero.jpg', new Uint8Array([0xff, 0xd8]), 'image/jpeg');
+    const provider = createMediaProviderFromContainer(container);
+    const url = await provider.resolveUrl('hero.jpg');
+    expect(url).toMatch(/^blob:/);
+    provider.dispose();
+  });
+
+  it('resolveUrl caches blob URLs', async () => {
+    await container.writeFile('hero.jpg', new Uint8Array([0xff, 0xd8]), 'image/jpeg');
+    const provider = createMediaProviderFromContainer(container);
+    const url1 = await provider.resolveUrl('hero.jpg');
+    const url2 = await provider.resolveUrl('hero.jpg');
+    expect(url1).toBe(url2);
+    provider.dispose();
+  });
+
+  it('listMedia excludes markdown files', async () => {
+    await container.writeFile('index.md', new TextEncoder().encode('# Doc'));
+    await container.writeFile('hero.jpg', new Uint8Array([0xff]), 'image/jpeg');
+    await container.writeFile('clip.mp4', new Uint8Array([0x00]), 'video/mp4');
+
+    const provider = createMediaProviderFromContainer(container);
+    const media = await provider.listMedia();
+    expect(media).toHaveLength(2);
+    expect(media.map((m) => m.name).sort()).toEqual(['clip.mp4', 'hero.jpg']);
+    provider.dispose();
+  });
+
+  it('addMedia writes to container and returns path', async () => {
+    const provider = createMediaProviderFromContainer(container);
+    const path = await provider.addMedia('photo.png', new Uint8Array([0x89]), 'image/png');
+    expect(path).toBe('photo.png');
+    expect(await container.exists('photo.png')).toBe(true);
+    provider.dispose();
+  });
+
+  it('removeMedia deletes from container', async () => {
+    await container.writeFile('hero.jpg', new Uint8Array([0xff]), 'image/jpeg');
+    const provider = createMediaProviderFromContainer(container);
+    // Resolve first to populate cache
+    await provider.resolveUrl('hero.jpg');
+    await provider.removeMedia('hero.jpg');
+    expect(await container.exists('hero.jpg')).toBe(false);
+    provider.dispose();
+  });
+});

package/src/__tests__/contentExtractor.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, it } from 'vitest';
+import {
+  extractContent,
+  stripMarkdown,
+  type ExtractionResult,
+} from '../generate/contentExtractor.js';
+
+const SAMPLE_TEXT = [
+  'Mount Rainier is the largest volcano in the Cascades, standing at 14,411 feet.',
+  'In July 1899, the mountain was designated a national park.',
+  'The park sees roughly 2 million visitors each year.',
+  '"The mountain was calling me," wrote John Muir after his 1888 expedition.',
+  'Temperatures range from 20 degrees to 70 degrees depending on elevation.',
+  'The park features hiking, camping, fishing, and climbing.',
+  'Imagine standing above the clouds at sunrise!',
+  'Paradise is a popular visitor area known for its wildflower meadows.',
+  'Rainier is the most glaciated peak in the lower 48 states.',
+].join(' ');
+
+describe('extractContent', () => {
+  let result: ExtractionResult;
+
+  // Run extraction once for all tests
+  it('extracts elements from sample text', () => {
+    result = extractContent(SAMPLE_TEXT);
+    expect(result.elements.length).toBeGreaterThan(0);
+    expect(result.sourceLength).toBe(SAMPLE_TEXT.length);
+  });
+
+  it('finds stats', () => {
+    const stats = result.elements.filter((e) => e.type === 'stat');
+    expect(stats.length).toBeGreaterThan(0);
+    // Should find 14,411 feet and/or 2 million
+    const values = stats.map((s) => (s.data.type === 'stat' ? s.data.value : ''));
+    expect(
+      values.some((v) => v.includes('14,411') || v.includes('2 million') || v.includes('feet')),
+    ).toBe(true);
+  });
+
+  it('finds dates', () => {
+    const dates = result.elements.filter((e) => e.type === 'date');
+    expect(dates.length).toBeGreaterThan(0);
+  });
+
+  it('finds quotes', () => {
+    const quotes = result.elements.filter((e) => e.type === 'quote');
+    expect(quotes.length).toBeGreaterThan(0);
+    const quoteData = quotes[0].data;
+    if (quoteData.type === 'quote') {
+      expect(quoteData.quote).toContain('mountain was calling me');
+    }
+  });
+
+  it('respects minConfidence filter', () => {
+    const strict = extractContent(SAMPLE_TEXT, { minConfidence: 0.9 });
+    const loose = extractContent(SAMPLE_TEXT, { minConfidence: 0.1 });
+    expect(loose.elements.length).toBeGreaterThanOrEqual(strict.elements.length);
+  });
+
+  it('respects types filter', () => {
+    const onlyStats = extractContent(SAMPLE_TEXT, { types: ['stat'] });
+    for (const elem of onlyStats.elements) {
+      expect(elem.type).toBe('stat');
+    }
+  });
+
+  it('respects maxPerType', () => {
+    const limited = extractContent(SAMPLE_TEXT, { maxPerType: 1 });
+    const typeCounts = new Map<string, number>();
+    for (const elem of limited.elements) {
+      typeCounts.set(elem.type, (typeCounts.get(elem.type) ?? 0) + 1);
+    }
+    for (const count of typeCounts.values()) {
+      expect(count).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it('deduplicates overlapping extractions', () => {
+    // Every element should have a unique source position range
+    for (let i = 0; i < result.elements.length; i++) {
+      for (let j = i + 1; j < result.elements.length; j++) {
+        const a = result.elements[i];
+        const b = result.elements[j];
+        // They shouldn't share the exact same start position
+        if (a.sourcePosition === b.sourcePosition) {
+          // If they overlap, one should have been removed by dedup
+          // (this is checking that the dedup is working at all)
+          expect(a.type).not.toBe(b.type);
+        }
+      }
+    }
+  });
+
+  it('returns correct stats counts', () => {
+    expect(result.stats.totalCount).toBe(result.elements.length);
+    expect(result.stats.statCount).toBe(result.elements.filter((e) => e.type === 'stat').length);
+  });
+
+  it('sorts elements by source position', () => {
+    for (let i = 1; i < result.elements.length; i++) {
+      expect(result.elements[i].sourcePosition).toBeGreaterThanOrEqual(
+        result.elements[i - 1].sourcePosition,
+      );
+    }
+  });
+});
+
+describe('extractContent — comparisons', () => {
+  it('detects "from X to Y" comparisons', () => {
+    const text = 'Temperatures range from 20 degrees to 70 degrees depending on altitude.';
+    const result = extractContent(text, { types: ['comparison'] });
+    expect(result.elements.length).toBeGreaterThan(0);
+    const comp = result.elements[0].data;
+    if (comp.type === 'comparison') {
+      expect(comp.left.label).toBeTruthy();
+      expect(comp.right.label).toBeTruthy();
+    }
+  });
+});
+
+describe('extractContent — impact lines', () => {
+  it('detects short punchy sentences', () => {
+    const text =
+      'Imagine standing above the clouds! Discover the hidden valley. The weather is variable.';
+    const result = extractContent(text, { types: ['impactLine'] });
+    expect(result.elements.length).toBeGreaterThan(0);
+  });
+});
+
+describe('extractContent — lists', () => {
+  it('detects "including X, Y, and Z" lists', () => {
+    const text = 'Activities including hiking, camping, fishing, and climbing are popular.';
+    const result = extractContent(text, { types: ['list'] });
+    expect(result.elements.length).toBeGreaterThan(0);
+    const listData = result.elements[0].data;
+    if (listData.type === 'list') {
+      expect(listData.items.length).toBeGreaterThanOrEqual(3);
+    }
+  });
+});
+
+describe('extractContent — definitions', () => {
+  it('detects "Term is a definition" patterns', () => {
+    const text =
+      'Paradise is a popular visitor area known for its wildflower meadows and scenic viewpoints.';
+    const result = extractContent(text, { types: ['definition'] });
+    expect(result.elements.length).toBeGreaterThan(0);
+    const defData = result.elements[0].data;
+    if (defData.type === 'definition') {
+      expect(defData.term).toBe('Paradise');
+    }
+  });
+});
+
+describe('stripMarkdown', () => {
+  it('removes headers', () => {
+    expect(stripMarkdown('# Hello\n## World')).toBe('Hello\nWorld');
+  });
+
+  it('removes bold and italic', () => {
+    expect(stripMarkdown('**bold** and *italic*')).toBe('bold and italic');
+  });
+
+  it('removes links, keeping text', () => {
+    expect(stripMarkdown('[Click here](https://example.com)')).toBe('Click here');
+  });
+
+  it('removes images entirely', () => {
+    expect(stripMarkdown('![alt text](image.png)')).toBe('');
+  });
+
+  it('removes code blocks', () => {
+    expect(stripMarkdown('before\n```js\ncode\n```\nafter')).toBe('before\n\nafter');
+  });
+
+  it('removes blockquote markers', () => {
+    expect(stripMarkdown('> quoted text')).toBe('quoted text');
+  });
+
+  it('collapses excess newlines', () => {
+    expect(stripMarkdown('a\n\n\n\nb')).toBe('a\n\nb');
+  });
+});

package/src/__tests__/seededRandom.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest';
+import { SeededRandom, hashString } from '../random/index.js';
+
+describe('SeededRandom', () => {
+  it('produces deterministic output from the same seed', () => {
+    const a = new SeededRandom(42);
+    const b = new SeededRandom(42);
+    expect(a.next()).toBe(b.next());
+    expect(a.next()).toBe(b.next());
+    expect(a.next()).toBe(b.next());
+  });
+
+  it('produces different output from different seeds', () => {
+    const a = new SeededRandom(1);
+    const b = new SeededRandom(2);
+    expect(a.next()).not.toBe(b.next());
+  });
+
+  it('next() returns values in [0, 1)', () => {
+    const rng = new SeededRandom(123);
+    for (let i = 0; i < 100; i++) {
+      const v = rng.next();
+      expect(v).toBeGreaterThanOrEqual(0);
+      expect(v).toBeLessThan(1);
+    }
+  });
+
+  it('nextInt(max) returns values in [0, max)', () => {
+    const rng = new SeededRandom(99);
+    for (let i = 0; i < 100; i++) {
+      const v = rng.nextInt(10);
+      expect(v).toBeGreaterThanOrEqual(0);
+      expect(v).toBeLessThan(10);
+      expect(Number.isInteger(v)).toBe(true);
+    }
+  });
+
+  it('nextIntRange(min, max) stays in range', () => {
+    const rng = new SeededRandom(77);
+    for (let i = 0; i < 100; i++) {
+      const v = rng.nextIntRange(5, 15);
+      expect(v).toBeGreaterThanOrEqual(5);
+      expect(v).toBeLessThan(15);
+    }
+  });
+
+  it('pick returns undefined for empty array', () => {
+    const rng = new SeededRandom(1);
+    expect(rng.pick([])).toBeUndefined();
+  });
+
+  it('pick returns an element from the array', () => {
+    const rng = new SeededRandom(1);
+    const items = ['a', 'b', 'c'];
+    const picked = rng.pick(items);
+    expect(items).toContain(picked);
+  });
+
+  it('pickRequired throws on empty array', () => {
+    const rng = new SeededRandom(1);
+    expect(() => rng.pickRequired([])).toThrow('Cannot pick from empty array');
+  });
+
+  it('pickMultiple returns correct count', () => {
+    const rng = new SeededRandom(42);
+    const result = rng.pickMultiple([1, 2, 3, 4, 5], 3);
+    expect(result).toHaveLength(3);
+    // All elements should be unique
+    expect(new Set(result).size).toBe(3);
+  });
+
+  it('pickMultiple returns all if count >= length', () => {
+    const rng = new SeededRandom(42);
+    const result = rng.pickMultiple([1, 2, 3], 5);
+    expect(result).toHaveLength(3);
+    expect(new Set(result).size).toBe(3);
+  });
+
+  it('shuffle is deterministic', () => {
+    const a = new SeededRandom(42);
+    const b = new SeededRandom(42);
+    expect(a.shuffle([1, 2, 3, 4, 5])).toEqual(b.shuffle([1, 2, 3, 4, 5]));
+  });
+
+  it('shuffled does not modify original', () => {
+    const rng = new SeededRandom(42);
+    const original = [1, 2, 3, 4, 5];
+    const copy = [...original];
+    rng.shuffled(original);
+    expect(original).toEqual(copy);
+  });
+
+  it('pickWeighted respects weights', () => {
+    // Heavily weight 'a' — over many picks it should dominate
+    const rng = new SeededRandom(42);
+    const items = [
+      { item: 'a', weight: 100 },
+      { item: 'b', weight: 1 },
+    ];
+    let aCount = 0;
+    for (let i = 0; i < 100; i++) {
+      if (rng.pickWeighted(items) === 'a') aCount++;
+    }
+    expect(aCount).toBeGreaterThan(80);
+  });
+
+  it('pickWeighted returns undefined for empty', () => {
+    const rng = new SeededRandom(1);
+    expect(rng.pickWeighted([])).toBeUndefined();
+  });
+
+  it('derive creates independent stream', () => {
+    const rng = new SeededRandom(42);
+    const d1 = rng.derive('stream-a');
+    const d2 = rng.derive('stream-b');
+    expect(d1.next()).not.toBe(d2.next());
+  });
+
+  it('handles seed of 0 gracefully', () => {
+    const rng = new SeededRandom(0);
+    const v = rng.next();
+    expect(v).toBeGreaterThanOrEqual(0);
+    expect(v).toBeLessThan(1);
+  });
+});
+
+describe('hashString', () => {
+  it('returns a positive 32-bit integer', () => {
+    const h = hashString('hello world');
+    expect(h).toBeGreaterThanOrEqual(0);
+    expect(h).toBeLessThanOrEqual(0xffffffff);
+    expect(Number.isInteger(h)).toBe(true);
+  });
+
+  it('is deterministic', () => {
+    expect(hashString('test')).toBe(hashString('test'));
+  });
+
+  it('differs for different strings', () => {
+    expect(hashString('abc')).not.toBe(hashString('xyz'));
+  });
+});