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

package/dist/__tests__/MusicTheory.test.js

@@ -1,245 +0,0 @@
-import { MusicTheory } from '../services/MusicTheory';
-describe('MusicTheory', () => {
-    let theory;
-    beforeEach(() => {
-        theory = new MusicTheory();
-    });
-    describe('generateScale', () => {
-        test('should generate correct major scale', () => {
-            const scale = theory.generateScale('C', 'major');
-            expect(scale).toEqual(['C', 'D', 'E', 'F', 'G', 'A', 'B']);
-        });
-        test('should generate correct minor scale', () => {
-            const scale = theory.generateScale('A', 'minor');
-            expect(scale).toEqual(['A', 'B', 'C', 'D', 'E', 'F', 'G']);
-        });
-        test('should generate correct dorian scale', () => {
-            const scale = theory.generateScale('D', 'dorian');
-            expect(scale).toEqual(['D', 'E', 'F', 'G', 'A', 'B', 'C']);
-        });
-        test('should generate correct pentatonic scale', () => {
-            const scale = theory.generateScale('C', 'pentatonic');
-            expect(scale).toEqual(['C', 'D', 'E', 'G', 'A']);
-        });
-        test('should generate correct blues scale', () => {
-            const scale = theory.generateScale('C', 'blues');
-            expect(scale).toEqual(['C', 'D#', 'F', 'F#', 'G', 'A#']);
-        });
-        test('should generate all modal scales correctly', () => {
-            const modes = ['dorian', 'phrygian', 'lydian', 'mixolydian', 'aeolian', 'locrian'];
-            modes.forEach(mode => {
-                const scale = theory.generateScale('C', mode);
-                expect(scale).toHaveLength(7);
-                expect(scale[0]).toBe('C');
-            });
-        });
-        test('should handle sharps correctly', () => {
-            const scale = theory.generateScale('F#', 'major');
-            expect(scale).toContain('F#');
-            expect(scale).toHaveLength(7);
-        });
-        test('should throw error for invalid root note', () => {
-            expect(() => theory.generateScale('X', 'major')).toThrow('Invalid root note: X');
-        });
-        test('should throw error for invalid scale type', () => {
-            expect(() => theory.generateScale('C', 'invalid')).toThrow('Invalid scale: invalid');
-        });
-        test('should handle all chromatic notes', () => {
-            const notes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
-            notes.forEach(note => {
-                const scale = theory.generateScale(note, 'major');
-                expect(scale).toHaveLength(7);
-                expect(scale[0]).toBe(note);
-            });
-        });
-    });
-    describe('generateChordProgression', () => {
-        test('should generate pop progression (I-V-vi-IV)', () => {
-            const progression = theory.generateChordProgression('C', 'pop');
-            expect(progression).toBe('"C" "G" "Am" "F"');
-        });
-        test('should generate jazz progression', () => {
-            const progression = theory.generateChordProgression('C', 'jazz');
-            expect(progression).toBe('"Dm7" "G7" "Cmaj7"');
-        });
-        test('should generate blues progression', () => {
-            const progression = theory.generateChordProgression('C', 'blues');
-            expect(progression).toContain('"C7"');
-            expect(progression.split(' ')).toHaveLength(12); // 12-bar blues
-        });
-        test('should handle different keys', () => {
-            const progressionC = theory.generateChordProgression('C', 'pop');
-            const progressionG = theory.generateChordProgression('G', 'pop');
-            expect(progressionC).not.toBe(progressionG);
-        });
-        test('should generate all progression types', () => {
-            const styles = ['pop', 'jazz', 'blues', 'folk', 'rock', 'classical', 'modal', 'edm'];
-            styles.forEach(style => {
-                const progression = theory.generateChordProgression('C', style);
-                expect(progression).toBeTruthy();
-                expect(progression.length).toBeGreaterThan(0);
-            });
-        });
-        test('should throw error for invalid style', () => {
-            expect(() => theory.generateChordProgression('C', 'invalid'))
-                .toThrow('Invalid progression style: invalid');
-        });
-    });
-    describe('getNote', () => {
-        test('should transpose notes correctly', () => {
-            expect(theory.getNote('C', 0)).toBe('C');
-            expect(theory.getNote('C', 2)).toBe('D');
-            expect(theory.getNote('C', 4)).toBe('E');
-            expect(theory.getNote('C', 5)).toBe('F');
-            expect(theory.getNote('C', 7)).toBe('G');
-            expect(theory.getNote('C', 9)).toBe('A');
-            expect(theory.getNote('C', 11)).toBe('B');
-        });
-        test('should wrap around octave', () => {
-            expect(theory.getNote('C', 12)).toBe('C');
-            expect(theory.getNote('C', 13)).toBe('C#');
-            expect(theory.getNote('C', 24)).toBe('C');
-        });
-        test('should handle sharps', () => {
-            expect(theory.getNote('C#', 2)).toBe('D#');
-            expect(theory.getNote('F#', 5)).toBe('B');
-        });
-        test('should return original note for invalid root', () => {
-            expect(theory.getNote('X', 5)).toBe('X');
-        });
-    });
-    describe('generateEuclideanRhythm', () => {
-        test('should generate valid Euclidean rhythm', () => {
-            const rhythm = theory.generateEuclideanRhythm(3, 8);
-            const hits = rhythm.split(' ').filter(x => x === '1').length;
-            expect(hits).toBe(3);
-        });
-        test('should handle different hit/step combinations', () => {
-            const testCases = [
-                { hits: 3, steps: 8 },
-                { hits: 5, steps: 8 },
-                { hits: 5, steps: 16 },
-                { hits: 7, steps: 16 },
-            ];
-            testCases.forEach(({ hits, steps }) => {
-                const rhythm = theory.generateEuclideanRhythm(hits, steps);
-                const actualHits = rhythm.split(' ').filter(x => x === '1').length;
-                expect(actualHits).toBe(hits);
-                expect(rhythm.split(' ')).toHaveLength(steps);
-            });
-        });
-        test('should distribute hits evenly', () => {
-            const rhythm = theory.generateEuclideanRhythm(4, 16);
-            const steps = rhythm.split(' ');
-            expect(steps).toHaveLength(16);
-            // Check that hits are evenly distributed (every 4 steps for 4 hits in 16 steps)
-            expect(steps[0]).toBe('1');
-            expect(steps[4]).toBe('1');
-            expect(steps[8]).toBe('1');
-            expect(steps[12]).toBe('1');
-        });
-        test('should throw error when hits exceed steps', () => {
-            expect(() => theory.generateEuclideanRhythm(10, 8))
-                .toThrow('Hits cannot exceed steps');
-        });
-        test('should handle edge cases', () => {
-            expect(theory.generateEuclideanRhythm(0, 8).split(' ').filter(x => x === '1')).toHaveLength(0);
-            expect(theory.generateEuclideanRhythm(8, 8).split(' ').filter(x => x === '1')).toHaveLength(8);
-            expect(theory.generateEuclideanRhythm(1, 16).split(' ').filter(x => x === '1')).toHaveLength(1);
-        });
-    });
-    describe('generatePolyrhythm', () => {
-        test('should generate polyrhythm with two patterns', () => {
-            const polyrhythm = theory.generatePolyrhythm(3, 5, 16);
-            expect(polyrhythm).toContain('[');
-            expect(polyrhythm).toContain(']');
-            expect(polyrhythm.split('],').length).toBe(2);
-        });
-        test('should use default length of 16', () => {
-            const polyrhythm = theory.generatePolyrhythm(3, 5);
-            const patterns = polyrhythm.split('], [');
-            patterns.forEach(pattern => {
-                const cleaned = pattern.replace(/[\[\]]/g, '');
-                expect(cleaned.split(' ')).toHaveLength(16);
-            });
-        });
-        test('should generate different rhythms for different patterns', () => {
-            const poly1 = theory.generatePolyrhythm(3, 5, 16);
-            const poly2 = theory.generatePolyrhythm(5, 3, 16);
-            expect(poly1).not.toBe(poly2);
-        });
-    });
-    describe('getScaleNotes', () => {
-        test('should return scale notes with octave numbers', () => {
-            const notes = theory.getScaleNotes('C', 'major', 3);
-            expect(notes).toEqual(['c3', 'd3', 'e3', 'f3', 'g3', 'a3', 'b3']);
-        });
-        test('should handle different octaves', () => {
-            const notes4 = theory.getScaleNotes('C', 'major', 4);
-            const notes5 = theory.getScaleNotes('C', 'major', 5);
-            expect(notes4).toEqual(['c4', 'd4', 'e4', 'f4', 'g4', 'a4', 'b4']);
-            expect(notes5).toEqual(['c5', 'd5', 'e5', 'f5', 'g5', 'a5', 'b5']);
-        });
-        test('should lowercase note names', () => {
-            const notes = theory.getScaleNotes('C#', 'major', 3);
-            notes.forEach(note => {
-                expect(note[0]).toBe(note[0].toLowerCase());
-            });
-        });
-    });
-    describe('generateArpeggio', () => {
-        test('should generate upward arpeggio', () => {
-            const arp = theory.generateArpeggio('C', 'up');
-            expect(arp).toBeTruthy();
-            expect(arp.split(' ')).toHaveLength(4);
-        });
-        test('should generate downward arpeggio', () => {
-            const arp = theory.generateArpeggio('C', 'down');
-            expect(arp).toBeTruthy();
-            expect(arp.split(' ')).toHaveLength(4);
-        });
-        test('should generate up-down arpeggio', () => {
-            const arp = theory.generateArpeggio('C', 'updown');
-            expect(arp.split(' ')).toHaveLength(6);
-        });
-        test('should generate random arpeggio', () => {
-            const arp = theory.generateArpeggio('C', 'random');
-            expect(arp.split(' ')).toHaveLength(8);
-        });
-        test('should default to up pattern for invalid pattern type', () => {
-            const arp = theory.generateArpeggio('C', 'invalid');
-            expect(arp.split(' ')).toHaveLength(4);
-        });
-        test('should handle different chord types', () => {
-            const chords = ['C', 'Cm', 'C7', 'Cmaj7', 'Cm7'];
-            chords.forEach(chord => {
-                const arp = theory.generateArpeggio(chord, 'up');
-                expect(arp).toBeTruthy();
-            });
-        });
-    });
-    describe('integration tests', () => {
-        test('should create complete musical context', () => {
-            const key = 'C';
-            const scale = theory.generateScale(key, 'major');
-            const progression = theory.generateChordProgression(key, 'pop');
-            const rhythm = theory.generateEuclideanRhythm(4, 16);
-            expect(scale).toHaveLength(7);
-            expect(progression).toContain('C');
-            expect(rhythm.split(' ')).toHaveLength(16);
-        });
-        test('should work with all supported scales and progressions', () => {
-            const scales = ['major', 'minor', 'dorian', 'phrygian', 'lydian', 'mixolydian',
-                'aeolian', 'locrian', 'pentatonic', 'blues'];
-            const progressions = ['pop', 'jazz', 'blues', 'folk', 'rock', 'classical', 'modal', 'edm'];
-            scales.forEach(scaleName => {
-                const scale = theory.generateScale('C', scaleName);
-                expect(scale.length).toBeGreaterThan(0);
-            });
-            progressions.forEach(style => {
-                const progression = theory.generateChordProgression('C', style);
-                expect(progression.length).toBeGreaterThan(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();
-        });
-    });
-});