@williamzujkowski/live-coding-music-mcp 2.0.0 → 3.0.0

package/dist/__tests__/PatternGenerator.test.js

@@ -1,337 +0,0 @@
-import { PatternGenerator } from '../services/PatternGenerator';
-describe('PatternGenerator', () => {
-    let generator;
-    beforeEach(() => {
-        generator = new PatternGenerator();
-    });
-    describe('generateDrumPattern', () => {
-        test('should generate techno drum pattern', () => {
-            const pattern = generator.generateDrumPattern('techno', 0.5);
-            expect(pattern).toContain('s(');
-            expect(pattern).toContain('bd');
-        });
-        test('should generate house drum pattern', () => {
-            const pattern = generator.generateDrumPattern('house', 0.5);
-            expect(pattern).toContain('s(');
-            expect(pattern).toContain('hh');
-        });
-        test('should handle complexity levels', () => {
-            const simple = generator.generateDrumPattern('techno', 0.0);
-            const complex = generator.generateDrumPattern('techno', 1.0);
-            expect(simple).toBeTruthy();
-            expect(complex).toBeTruthy();
-            expect(simple.length).toBeLessThanOrEqual(complex.length);
-        });
-        test('should generate all supported drum styles', () => {
-            const styles = ['techno', 'house', 'dnb', 'breakbeat', 'trap', 'jungle', 'ambient', 'experimental'];
-            styles.forEach(style => {
-                const pattern = generator.generateDrumPattern(style, 0.5);
-                expect(pattern).toBeTruthy();
-                expect(pattern).toContain('s(');
-            });
-        });
-        test('should default to techno for unknown styles', () => {
-            const pattern = generator.generateDrumPattern('unknown', 0.5);
-            expect(pattern).toBeTruthy();
-            expect(pattern).toContain('bd');
-        });
-        test('should handle complexity edge cases', () => {
-            expect(generator.generateDrumPattern('techno', 0)).toBeTruthy();
-            expect(generator.generateDrumPattern('techno', 1)).toBeTruthy();
-            expect(generator.generateDrumPattern('techno', 0.5)).toBeTruthy();
-        });
-    });
-    describe('generateBassline', () => {
-        test('should generate techno bassline', () => {
-            const bass = generator.generateBassline('C', 'techno');
-            expect(bass).toContain('note(');
-            expect(bass).toContain('C2');
-            expect(bass).toContain('sawtooth');
-        });
-        test('should generate house bassline', () => {
-            const bass = generator.generateBassline('D', 'house');
-            expect(bass).toContain('D2');
-            expect(bass).toContain('sine');
-        });
-        test('should generate acid bassline with modulation', () => {
-            const bass = generator.generateBassline('E', 'acid');
-            expect(bass).toContain('E2');
-            expect(bass).toContain('cutoff');
-            expect(bass).toContain('sine.range');
-        });
-        test('should handle all supported bass styles', () => {
-            const styles = ['techno', 'house', 'dnb', 'acid', 'dub', 'funk', 'jazz', 'ambient'];
-            styles.forEach(style => {
-                const bass = generator.generateBassline('C', style);
-                expect(bass).toContain('note(');
-                expect(bass).toContain('C');
-            });
-        });
-        test('should work with different keys', () => {
-            const keys = ['C', 'D', 'E', 'F', 'G', 'A', 'B', 'C#', 'F#'];
-            keys.forEach(key => {
-                const bass = generator.generateBassline(key, 'techno');
-                expect(bass).toContain(key);
-            });
-        });
-        test('should default to techno for unknown styles', () => {
-            const bass = generator.generateBassline('C', 'unknown');
-            expect(bass).toContain('sawtooth');
-        });
-    });
-    describe('generateMelody', () => {
-        test('should generate melody from scale', () => {
-            const scale = ['c', 'd', 'e', 'f', 'g', 'a', 'b'];
-            const melody = generator.generateMelody(scale, 8);
-            expect(melody).toContain('note(');
-            expect(melody).toContain('triangle');
-        });
-        test('should generate melody with specified length', () => {
-            const scale = ['c', 'd', 'e'];
-            const melody4 = generator.generateMelody(scale, 4);
-            const melody8 = generator.generateMelody(scale, 8);
-            const melody16 = generator.generateMelody(scale, 16);
-            const notes4 = melody4.match(/[a-g]\d+/g);
-            const notes8 = melody8.match(/[a-g]\d+/g);
-            const notes16 = melody16.match(/[a-g]\d+/g);
-            expect(notes4?.length).toBe(4);
-            expect(notes8?.length).toBe(8);
-            expect(notes16?.length).toBe(16);
-        });
-        test('should respect octave range', () => {
-            const scale = ['c', 'd', 'e', 'f', 'g'];
-            const melody = generator.generateMelody(scale, 8, [4, 5]);
-            const notes = melody.match(/[a-g](\d+)/g) || [];
-            notes.forEach(note => {
-                const octave = parseInt(note.slice(-1));
-                expect(octave).toBeGreaterThanOrEqual(4);
-                expect(octave).toBeLessThanOrEqual(5);
-            });
-        });
-        test('should use default parameters', () => {
-            const scale = ['c', 'd', 'e'];
-            const melody = generator.generateMelody(scale);
-            expect(melody).toBeTruthy();
-            expect(melody).toContain('note(');
-        });
-        test('should only use notes from provided scale', () => {
-            const scale = ['c', 'e', 'g'];
-            const melody = generator.generateMelody(scale, 8);
-            const notePattern = /([a-g]#?)\d+/g;
-            const matches = melody.match(notePattern) || [];
-            matches.forEach(match => {
-                const note = match.replace(/\d+/g, '');
-                expect(scale).toContain(note);
-            });
-        });
-    });
-    describe('generateChords', () => {
-        test('should generate triad voicing', () => {
-            const chords = generator.generateChords('"C" "F" "G"', 'triad');
-            expect(chords).toContain('note(');
-            expect(chords).toContain('sawtooth');
-            expect(chords).toContain('.struct("1 ~ ~ ~")');
-        });
-        test('should generate sustained voicing', () => {
-            const chords = generator.generateChords('"C" "F"', 'sustained');
-            expect(chords).toContain('.attack(0.5)');
-            expect(chords).toContain('.release(2)');
-        });
-        test('should generate pad voicing', () => {
-            const chords = generator.generateChords('"C"', 'pad');
-            expect(chords).toContain('.attack(2)');
-            expect(chords).toContain('.release(4)');
-            expect(chords).toContain('.room(0.8)');
-        });
-        test('should default to triad for unknown voicing', () => {
-            const chords = generator.generateChords('"C"', 'unknown');
-            expect(chords).toContain('.struct("1 ~ ~ ~")');
-        });
-    });
-    describe('generateCompletePattern', () => {
-        test('should generate complete techno pattern', () => {
-            const pattern = generator.generateCompletePattern('techno', 'C', 130);
-            expect(pattern).toContain('// techno');
-            expect(pattern).toContain('setcpm(130)');
-            expect(pattern).toContain('stack(');
-            expect(pattern).toContain('// Drums');
-            expect(pattern).toContain('// Bass');
-            expect(pattern).toContain('// Chords');
-            expect(pattern).toContain('// Melody');
-        });
-        test('should generate pattern for different styles', () => {
-            const styles = ['techno', 'house', 'jazz', 'ambient'];
-            styles.forEach(style => {
-                const pattern = generator.generateCompletePattern(style, 'C', 120);
-                expect(pattern).toContain(`// ${style}`);
-                expect(pattern).toContain('stack(');
-            });
-        });
-        test('should use correct key', () => {
-            const pattern = generator.generateCompletePattern('house', 'D', 120);
-            expect(pattern).toContain('D');
-        });
-        test('should set correct BPM', () => {
-            const pattern140 = generator.generateCompletePattern('dnb', 'C', 140);
-            const pattern90 = generator.generateCompletePattern('ambient', 'C', 90);
-            expect(pattern140).toContain('setcpm(140)');
-            expect(pattern90).toContain('setcpm(90)');
-        });
-        test('should use appropriate scale for style', () => {
-            const jazzPattern = generator.generateCompletePattern('jazz', 'C', 120);
-            const technoPattern = generator.generateCompletePattern('techno', 'C', 120);
-            // Jazz should use dorian, others use minor (indirectly verified through note choices)
-            expect(jazzPattern).toBeTruthy();
-            expect(technoPattern).toBeTruthy();
-        });
-    });
-    describe('generateVariation', () => {
-        test('should add subtle variation', () => {
-            const base = 's("bd*4")';
-            const varied = generator.generateVariation(base, 'subtle');
-            expect(varied).toContain(base);
-            expect(varied).toContain('.sometimes');
-        });
-        test('should add moderate variation', () => {
-            const base = 's("bd*4")';
-            const varied = generator.generateVariation(base, 'moderate');
-            expect(varied).toContain('.every(4');
-            expect(varied).toContain('.sometimes');
-        });
-        test('should add extreme variation', () => {
-            const base = 's("bd*4")';
-            const varied = generator.generateVariation(base, 'extreme');
-            expect(varied).toContain('.every(2');
-            expect(varied).toContain('.jux');
-        });
-        test('should add glitch variation', () => {
-            const base = 's("bd*4")';
-            const varied = generator.generateVariation(base, 'glitch');
-            expect(varied).toContain('.chop');
-        });
-        test('should add evolving variation', () => {
-            const base = 's("bd*4")';
-            const varied = generator.generateVariation(base, 'evolving');
-            expect(varied).toContain('.slow(4)');
-            expect(varied).toContain('.palindrome');
-        });
-        test('should default to subtle for unknown type', () => {
-            const base = 's("bd*4")';
-            const varied = generator.generateVariation(base, 'unknown');
-            expect(varied).toContain('.sometimes');
-        });
-    });
-    describe('generateFill', () => {
-        test('should generate techno fill', () => {
-            const fill = generator.generateFill('techno', 1);
-            expect(fill).toContain('s(');
-            expect(fill).toContain('bd');
-        });
-        test('should handle different bar lengths', () => {
-            const fill1 = generator.generateFill('house', 1);
-            const fill2 = generator.generateFill('house', 2);
-            expect(fill1).toContain('.fast(1)');
-            expect(fill2).toContain('.fast(2)');
-        });
-        test('should generate fills for all supported styles', () => {
-            const styles = ['techno', 'house', 'dnb', 'trap', 'breakbeat'];
-            styles.forEach(style => {
-                const fill = generator.generateFill(style, 1);
-                expect(fill).toBeTruthy();
-            });
-        });
-        test('should default to techno for unknown style', () => {
-            const fill = generator.generateFill('unknown', 1);
-            expect(fill).toContain('bd');
-        });
-    });
-    describe('generateTransition', () => {
-        test('should generate transition between styles', () => {
-            const transition = generator.generateTransition('techno', 'house', 4);
-            expect(transition).toContain('// Transition from techno to house');
-            expect(transition).toContain('stack(');
-            expect(transition).toContain('// Fade out techno');
-            expect(transition).toContain('// Fade in house');
-        });
-        test('should use specified bar length', () => {
-            const transition8 = generator.generateTransition('house', 'dnb', 8);
-            expect(transition8).toContain('.slow(8)');
-        });
-    });
-    describe('generateEuclideanPattern', () => {
-        test('should generate Euclidean pattern with default sound', () => {
-            const pattern = generator.generateEuclideanPattern(3, 8);
-            expect(pattern).toContain('s("bd")');
-            expect(pattern).toContain('.struct(');
-        });
-        test('should use specified sound', () => {
-            const pattern = generator.generateEuclideanPattern(5, 16, 'cp');
-            expect(pattern).toContain('s("cp")');
-        });
-        test('should generate valid rhythm structure', () => {
-            const pattern = generator.generateEuclideanPattern(4, 12, 'hh');
-            expect(pattern).toContain('struct');
-            // Pattern should contain the rhythm from MusicTheory
-            expect(pattern).toMatch(/1.*~/);
-        });
-    });
-    describe('generatePolyrhythm', () => {
-        test('should generate polyrhythm with multiple sounds', () => {
-            const sounds = ['bd', 'cp', 'hh'];
-            const patterns = [3, 5, 7];
-            const poly = generator.generatePolyrhythm(sounds, patterns);
-            expect(poly).toContain('stack(');
-            expect(poly).toContain('s("bd")');
-            expect(poly).toContain('s("cp")');
-            expect(poly).toContain('s("hh")');
-            expect(poly).toContain('.euclid(3, 16)');
-            expect(poly).toContain('.euclid(5, 16)');
-            expect(poly).toContain('.euclid(7, 16)');
-        });
-        test('should throw error for mismatched arrays', () => {
-            const sounds = ['bd', 'cp'];
-            const patterns = [3, 5, 7];
-            expect(() => generator.generatePolyrhythm(sounds, patterns))
-                .toThrow('Number of sounds must match number of patterns');
-        });
-        test('should handle single sound/pattern pair', () => {
-            const poly = generator.generatePolyrhythm(['bd'], [4]);
-            expect(poly).toContain('s("bd")');
-            expect(poly).toContain('.euclid(4, 16)');
-        });
-        test('should handle empty arrays', () => {
-            expect(() => generator.generatePolyrhythm([], []))
-                .not.toThrow();
-        });
-    });
-    describe('integration tests', () => {
-        test('should create complete musical composition', () => {
-            const pattern = generator.generateCompletePattern('house', 'Am', 125);
-            const variation = generator.generateVariation(pattern, 'moderate');
-            expect(pattern).toBeTruthy();
-            expect(variation).toContain(pattern);
-        });
-        test('should combine multiple generators', () => {
-            const drums = generator.generateDrumPattern('techno', 0.7);
-            const bass = generator.generateBassline('C', 'techno');
-            const fill = generator.generateFill('techno', 1);
-            expect(drums).toBeTruthy();
-            expect(bass).toBeTruthy();
-            expect(fill).toBeTruthy();
-        });
-        test('should handle complex workflow', () => {
-            // Create initial pattern
-            const initial = generator.generateCompletePattern('dnb', 'D', 174);
-            expect(initial).toBeTruthy();
-            // Add variation
-            const varied = generator.generateVariation(initial, 'glitch');
-            expect(varied).toContain(initial);
-            // Generate transition
-            const transition = generator.generateTransition('dnb', 'ambient', 8);
-            expect(transition).toBeTruthy();
-            // Generate final pattern
-            const final = generator.generateCompletePattern('ambient', 'D', 80);
-            expect(final).toBeTruthy();
-        });
-    });
-});

package/dist/__tests__/PatternStore.test.js

@@ -1,153 +0,0 @@
-import { PatternStore } from '../PatternStore';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { tmpdir } from 'os';
-describe('PatternStore', () => {
-    let store;
-    let testDir;
-    beforeEach(async () => {
-        // Create a temporary directory for testing
-        testDir = path.join(tmpdir(), 'strudel-test-' + Date.now());
-        await fs.mkdir(testDir, { recursive: true });
-        store = new PatternStore(testDir);
-    });
-    afterEach(async () => {
-        // Clean up test directory
-        try {
-            await fs.rm(testDir, { recursive: true, force: true });
-        }
-        catch (error) {
-            // Ignore cleanup errors
-        }
-    });
-    describe('save', () => {
-        test('should save a pattern successfully', async () => {
-            const name = 'test-pattern';
-            const content = 's("bd*4")';
-            const tags = ['techno', 'test'];
-            await store.save(name, content, tags);
-            const files = await fs.readdir(testDir);
-            expect(files).toContain('test-pattern.json');
-        });
-        test('should sanitize filename', async () => {
-            const name = 'Test Pattern With Spaces!@#';
-            const content = 's("bd*4")';
-            await store.save(name, content);
-            const files = await fs.readdir(testDir);
-            expect(files).toContain('test_pattern_with_spaces___.json');
-        });
-        test('should save pattern with timestamp', async () => {
-            const name = 'timestamped';
-            const content = 's("bd*4")';
-            await store.save(name, content);
-            const pattern = await store.load(name);
-            expect(pattern).not.toBeNull();
-            expect(pattern.timestamp).toBeDefined();
-            expect(new Date(pattern.timestamp).getTime()).toBeGreaterThan(0);
-        });
-        test('should overwrite existing pattern', async () => {
-            const name = 'overwrite-test';
-            await store.save(name, 's("bd*4")');
-            await store.save(name, 's("cp*4")');
-            const pattern = await store.load(name);
-            expect(pattern.content).toBe('s("cp*4")');
-        });
-    });
-    describe('load', () => {
-        test('should load an existing pattern', async () => {
-            const name = 'loadable';
-            const content = 's("bd*4, cp*2")';
-            const tags = ['house'];
-            await store.save(name, content, tags);
-            const loaded = await store.load(name);
-            expect(loaded).not.toBeNull();
-            expect(loaded.name).toBe(name);
-            expect(loaded.content).toBe(content);
-            expect(loaded.tags).toEqual(tags);
-        });
-        test('should return null for non-existent pattern', async () => {
-            const loaded = await store.load('does-not-exist');
-            expect(loaded).toBeNull();
-        });
-        test('should handle sanitized filenames when loading', async () => {
-            const name = 'Pattern With Spaces';
-            const content = 's("bd*4")';
-            await store.save(name, content);
-            const loaded = await store.load(name);
-            expect(loaded).not.toBeNull();
-            expect(loaded.name).toBe(name);
-        });
-    });
-    describe('list', () => {
-        test('should list all patterns', async () => {
-            await store.save('pattern1', 's("bd*4")', ['techno']);
-            await store.save('pattern2', 's("cp*4")', ['house']);
-            await store.save('pattern3', 's("hh*8")', ['dnb']);
-            const patterns = await store.list();
-            expect(patterns).toHaveLength(3);
-            expect(patterns.map(p => p.name).sort()).toEqual(['pattern1', 'pattern2', 'pattern3']);
-        });
-        test('should filter patterns by tag', async () => {
-            await store.save('pattern1', 's("bd*4")', ['techno', 'dark']);
-            await store.save('pattern2', 's("cp*4")', ['house']);
-            await store.save('pattern3', 's("hh*8")', ['techno']);
-            const technoPatterns = await store.list('techno');
-            expect(technoPatterns).toHaveLength(2);
-            expect(technoPatterns.map(p => p.name).sort()).toEqual(['pattern1', 'pattern3']);
-        });
-        test('should return patterns sorted by timestamp (newest first)', async () => {
-            await store.save('old', 's("bd*4")');
-            await new Promise(resolve => setTimeout(resolve, 10));
-            await store.save('middle', 's("cp*4")');
-            await new Promise(resolve => setTimeout(resolve, 10));
-            await store.save('new', 's("hh*8")');
-            const patterns = await store.list();
-            expect(patterns[0].name).toBe('new');
-            expect(patterns[1].name).toBe('middle');
-            expect(patterns[2].name).toBe('old');
-        });
-        test('should return empty array for empty directory', async () => {
-            const patterns = await store.list();
-            expect(patterns).toEqual([]);
-        });
-        test('should ignore non-JSON files', async () => {
-            await store.save('valid', 's("bd*4")');
-            await fs.writeFile(path.join(testDir, 'invalid.txt'), 'not json');
-            const patterns = await store.list();
-            expect(patterns).toHaveLength(1);
-            expect(patterns[0].name).toBe('valid');
-        });
-    });
-    describe('edge cases', () => {
-        test('should handle patterns with special characters in content', async () => {
-            const name = 'special';
-            const content = 's("bd*4").room(0.9)\n// Comment with "quotes"';
-            await store.save(name, content);
-            const loaded = await store.load(name);
-            expect(loaded.content).toBe(content);
-        });
-        test('should handle very long pattern names', async () => {
-            const name = 'a'.repeat(200);
-            const content = 's("bd*4")';
-            await store.save(name, content);
-            const loaded = await store.load(name);
-            expect(loaded).not.toBeNull();
-            expect(loaded.name).toBe(name);
-        });
-        test('should handle empty tags array', async () => {
-            const name = 'no-tags';
-            const content = 's("bd*4")';
-            await store.save(name, content, []);
-            const loaded = await store.load(name);
-            expect(loaded.tags).toEqual([]);
-        });
-        test('should handle unicode characters in names', async () => {
-            const name = 'パターン-テスト';
-            const content = 's("bd*4")';
-            await store.save(name, content);
-            const loaded = await store.load(name);
-            expect(loaded).not.toBeNull();
-            expect(loaded.name).toBe(name);
-        });
-    });
-});

package/dist/__tests__/utils/MockPlaywright.js

@@ -1,130 +0,0 @@
-export class MockPage {
-    content = '';
-    isPlayingState = false;
-    evaluateHandlers = new Map();
-    url = '';
-    async goto(url, options) {
-        this.url = url;
-        return {};
-    }
-    async waitForSelector(selector, options) {
-        return {};
-    }
-    async waitForTimeout(timeout) {
-        return new Promise(resolve => setTimeout(resolve, Math.min(timeout, 10)));
-    }
-    async click(selector, options) {
-        if (selector.includes('play')) {
-            this.isPlayingState = true;
-        }
-        else if (selector.includes('stop')) {
-            this.isPlayingState = false;
-        }
-    }
-    async type(text, options) {
-        this.content += text;
-    }
-    async route(url, handler) {
-        // Mock route interception
-    }
-    keyboard = {
-        press: async (key) => {
-            if (key.includes('Enter')) {
-                this.isPlayingState = true;
-            }
-            else if (key.includes('Period')) {
-                this.isPlayingState = false;
-            }
-            else if (key.includes('A')) {
-                this.content = '';
-            }
-        },
-        type: async (text) => {
-            this.content += text;
-        }
-    };
-    async evaluate(fn, ...args) {
-        // Simulate common evaluate calls
-        const fnString = fn.toString();
-        if (fnString.includes('strudelAudioAnalyzer')) {
-            if (fnString.includes('connect()')) {
-                return undefined;
-            }
-            if (fnString.includes('analyze()')) {
-                return {
-                    connected: true,
-                    timestamp: Date.now(),
-                    features: {
-                        average: 50,
-                        peak: 100,
-                        peakFrequency: 440,
-                        centroid: 250,
-                        bass: 60,
-                        lowMid: 50,
-                        mid: 40,
-                        highMid: 30,
-                        treble: 20,
-                        isPlaying: this.isPlayingState,
-                        isSilent: !this.isPlayingState,
-                        bassToTrebleRatio: '3.00',
-                        brightness: 'balanced'
-                    }
-                };
-            }
-        }
-        if (fnString.includes('.cm-content')) {
-            if (fnString.includes('textContent')) {
-                return this.content;
-            }
-            if (fnString.includes('dispatch')) {
-                const newContent = args[0];
-                if (typeof newContent === 'string') {
-                    this.content = newContent;
-                }
-                return undefined;
-            }
-        }
-        // Allow custom handlers
-        for (const [key, handler] of this.evaluateHandlers.entries()) {
-            if (fnString.includes(key)) {
-                return handler(...args);
-            }
-        }
-        return undefined;
-    }
-    setEvaluateHandler(key, handler) {
-        this.evaluateHandlers.set(key, handler);
-    }
-    getContent() {
-        return this.content;
-    }
-    setContent(content) {
-        this.content = content;
-    }
-    isPlaying() {
-        return this.isPlayingState;
-    }
-}
-export class MockBrowserContext {
-    async newPage() {
-        return new MockPage();
-    }
-}
-export class MockBrowser {
-    closed = false;
-    async newContext(options) {
-        return new MockBrowserContext();
-    }
-    async close() {
-        this.closed = true;
-    }
-    isClosed() {
-        return this.closed;
-    }
-}
-export const createMockBrowser = () => {
-    return new MockBrowser();
-};
-export const createMockPage = () => {
-    return new MockPage();
-};