@williamzujkowski/live-coding-music-mcp 1.0.0

package/dist/services/PatternGenerator.js

@@ -0,0 +1,647 @@
+import { MusicTheory } from './MusicTheory.js';
+export class PatternGenerator {
+    theory = new MusicTheory();
+    // Note interval lookup for chord calculations
+    notes = ['c', 'db', 'd', 'eb', 'e', 'f', 'gb', 'g', 'ab', 'a', 'bb', 'b'];
+    /**
+     * Get a note at a specific interval from the root
+     */
+    getInterval(root, semitones) {
+        const normalizedRoot = root.toLowerCase().replace('#', 'b');
+        const sharpToFlat = {
+            'c#': 'db', 'd#': 'eb', 'f#': 'gb', 'g#': 'ab', 'a#': 'bb'
+        };
+        const searchRoot = sharpToFlat[normalizedRoot] || normalizedRoot;
+        const idx = this.notes.indexOf(searchRoot);
+        if (idx === -1)
+            return root;
+        return this.notes[(idx + semitones) % 12];
+    }
+    getFourth(root) { return this.getInterval(root, 5); }
+    getFifth(root) { return this.getInterval(root, 7); }
+    getMinorThird(root) { return this.getInterval(root, 3); }
+    getMinorSeventh(root) { return this.getInterval(root, 10); }
+    /**
+     * Generates a drum pattern for a given style
+     * @param style - Music style (e.g., 'techno', 'house', 'dnb', 'ambient')
+     * @param complexity - Pattern complexity from 0 to 1 (default: 1)
+     * @returns Strudel drum pattern code
+     */
+    generateDrumPattern(style, complexity = 1) {
+        const patterns = {
+            techno: [
+                's("bd*4")',
+                's("bd*4, ~ cp ~ cp")',
+                's("bd*4, ~ cp ~ cp, hh*8")',
+                's("bd*4, ~ cp ~ cp, [~ hh]*4, oh ~ ~ ~").swing(0.05)'
+            ],
+            house: [
+                's("bd*4, hh*8")',
+                's("bd*4, hh*8, ~ cp ~ cp")',
+                's("bd*4, [~ hh]*4, ~ cp ~ cp, oh ~ oh ~")',
+                's("bd*4, [~ hh]*4, ~ cp ~ cp").every(4, x => x.fast(2))'
+            ],
+            dnb: [
+                's("bd ~ ~ bd ~ ~ bd ~, ~ ~ cp ~ ~ cp ~ ~")',
+                's("bd ~ ~ [bd bd] ~ ~ bd ~, ~ ~ cp ~ ~ cp ~ ~, hh*16")',
+                's("bd ~ ~ [bd bd] ~ ~ bd ~, ~ ~ cp ~ [~ cp] ~ cp ~ ~, hh*16").fast(2)'
+            ],
+            breakbeat: [
+                's("bd ~ ~ bd ~ ~ ~ bd, ~ cp ~ ~ cp ~")',
+                's("bd ~ ~ bd ~ [~ bd] ~ bd, ~ cp ~ ~ cp ~, hh*8")',
+                's("bd ~ [~ bd] bd ~ [~ bd] ~ bd, ~ cp ~ ~ cp [~ cp], hh*8").swing(0.1)'
+            ],
+            trap: [
+                's("bd*2, ~ cp ~ cp")',
+                's("bd*2, ~ cp ~ cp, hh*8").every(2, x => x.fast(2))',
+                's("bd [bd bd] ~ bd, ~ cp ~ cp, hh*16").swing(0.2)'
+            ],
+            jungle: [
+                's("bd ~ [~ bd] bd ~ ~ bd ~, ~ cp ~ ~ cp ~").fast(2)',
+                's("bd ~ [~ bd] bd ~ [bd bd] bd ~, ~ cp ~ [~ cp] cp ~, hh*32").fast(2)'
+            ],
+            ambient: [
+                's("bd ~ ~ ~")',
+                's("bd ~ ~ ~, ~ ~ ~ hh:8").room(0.9)',
+                's("bd ~ ~ ~, ~ ~ ~ hh:8, ~ ~ oh:5 ~").room(0.9).gain(0.5)'
+            ],
+            experimental: [
+                's("bd").euclid(5, 8)',
+                's("bd cp").euclid(7, 16)',
+                's("bd cp hh").euclid(choose([3, 5, 7]), 16)'
+            ],
+            // === NEW GENRES ===
+            intelligent_dnb: [
+                // Minimal - sparse break
+                `s("breaks165").fit().slice(8, "0 ~ ~ 3 ~ ~ 6 ~").gain(0.5).room(0.3).lpf(5000)`,
+                // Medium - classic rolling break
+                `s("breaks165").fit().slice(8, "0 0 6 3 0 2 6 7").gain(0.7).room(0.2)`,
+                // Complex - layered breaks
+                `stack(
+          s("breaks165").fit().slice(8, "0 0 6 3 0 2 6 7").gain(0.65).room(0.2),
+          s("breaks165").fit().chop(16).gain(0.12).hpf(3000).room(0.4),
+          s("bd ~ ~ ~ [~ bd] ~ bd ~").bank("RolandTR909").gain(0.45).lpf(100)
+        )`
+            ],
+            trip_hop: [
+                // Minimal - sparse and moody
+                `s("bd ~ ~ ~, ~ ~ ~ sd:3").room(0.5).gain(0.7)`,
+                // Medium - classic trip hop groove
+                `stack(
+          s("bd ~ ~ bd ~ ~ bd ~").gain(0.8),
+          s("~ ~ ~ ~ sd ~ ~ ~").bank("RolandTR808").gain(0.7).room(0.4),
+          s("hh*8").gain(0.25).hpf(6000).pan(sine.range(0.3, 0.7))
+        )`,
+                // Complex - layered with vinyl texture
+                `stack(
+          s("bd ~ [~ bd] ~ bd ~ ~ ~").gain(0.8),
+          s("~ ~ ~ ~ sd ~ ~ sd:2?").bank("RolandTR808").gain(0.7).room(0.5),
+          s("hh*8").gain(perlin.range(0.15, 0.3)).hpf(5000),
+          s("~ oh ~ ~ ~ oh ~ ~").bank("RolandTR808").gain(0.2).room(0.6)
+        ).slow(2)`
+            ],
+            boom_bap: [
+                // Minimal - hard kick and snare
+                `s("bd ~ ~ ~ sd ~ ~ ~, bd ~ ~ ~ sd ~ bd ~")`,
+                // Medium - classic boom bap with hats
+                `stack(
+          s("bd ~ ~ ~ sd ~ ~ ~, bd ~ ~ bd sd ~ bd ~").gain(0.9),
+          s("hh*8").gain(0.4).hpf(5000),
+          s("~ ~ oh ~ ~ ~ oh ~").gain(0.3)
+        ).swing(0.08)`,
+                // Complex - layered golden era style
+                `stack(
+          s("bd ~ ~ [~ bd] sd ~ ~ ~, bd ~ ~ bd sd ~ [bd bd] ~").gain(0.9),
+          s("~ ~ ~ ~ sd:3 ~ ~ ~").gain(0.3).room(0.2),
+          s("[~ hh]*8").gain(0.45).hpf(4000),
+          s("~ ~ oh ~ ~ ~ ~ oh:2").gain(0.25).room(0.3)
+        ).swing(0.1)`
+            ]
+        };
+        // Handle aliases
+        const styleMap = {
+            'liquid_dnb': 'intelligent_dnb',
+            'atmospheric_dnb': 'intelligent_dnb',
+            'intelligent': 'intelligent_dnb',
+            'liquid': 'intelligent_dnb',
+            'atmospheric': 'intelligent_dnb',
+            'bukem': 'intelligent_dnb',
+            'triphop': 'trip_hop',
+            'portishead': 'trip_hop',
+            'massive_attack': 'trip_hop',
+            'flying_lotus': 'trip_hop',
+            'boombap': 'boom_bap',
+            'golden_era': 'boom_bap',
+            'premier': 'boom_bap',
+            'alchemist': 'boom_bap',
+            'daringer': 'boom_bap',
+            'hitboy': 'boom_bap'
+        };
+        const resolvedStyle = styleMap[style.toLowerCase()] || style.toLowerCase();
+        const stylePatterns = patterns[resolvedStyle] || patterns.techno;
+        const index = Math.min(Math.floor(complexity * stylePatterns.length), stylePatterns.length - 1);
+        return stylePatterns[index];
+    }
+    /**
+     * Generates a bassline pattern for a given key and style
+     * @param key - Musical key (e.g., 'C', 'D', 'F#')
+     * @param style - Music style (e.g., 'techno', 'house', 'acid', 'dub')
+     * @returns Strudel bassline pattern code
+     */
+    generateBassline(key, style) {
+        const safeKey = key.toLowerCase();
+        const fourth = this.getFourth(safeKey);
+        const fifth = this.getFifth(safeKey);
+        const minorSeventh = this.getMinorSeventh(safeKey);
+        const patterns = {
+            techno: `note("${key}2 ${key}2 ${key}2 ${key}2").s("sawtooth").cutoff(800)`,
+            house: `note("${key}2 ~ ${key}2 ~").s("sine").gain(0.8)`,
+            dnb: `note("${key}1 ~ ~ ${key}2 ~ ${key}1 ~ ~").s("square").cutoff(400)`,
+            acid: `note("${key}2 ${key}3 ${key}2 ${this.theory.getNote(key, 3)}2").s("sawtooth").cutoff(sine.range(200, 2000).slow(4))`,
+            dub: `note("${key}1 ~ ~ ~ ${key}1 ~ ${this.theory.getNote(key, 5)}1 ~").s("sine:2").room(0.5)`,
+            funk: `note("${key}2 ${key}2 ~ ${this.theory.getNote(key, 5)}2 ~ ${key}2 ${this.theory.getNote(key, 7)}2 ~").s("square").cutoff(1200)`,
+            jazz: `note("${key}2 ~ ${this.theory.getNote(key, 4)}2 ~ ${this.theory.getNote(key, 7)}2 ~").s("sine").gain(0.7)`,
+            ambient: `note("${key}1").s("sine").attack(2).release(4).gain(0.6)`,
+            // === NEW GENRES ===
+            intelligent_dnb: `note("<${safeKey}1 ~ ${safeKey}1 ~> <${fourth}1 ~ ~ ${fourth}1> <${minorSeventh}0 ~ ${minorSeventh}0 ~> <${this.getMinorThird(safeKey)}1 ~ ~ ~>")
+        .s("sine")
+        .gain(0.65)
+        .lpf(80)
+        .attack(0.01)
+        .decay(0.2)
+        .sustain(0.5)
+        .release(0.4)`,
+            trip_hop: `note("<${safeKey}1 ~ ~ ${safeKey}1> <~ ${fourth}1 ~ ~> <${fifth}1 ~ ${safeKey}1 ~> <~ ~ ${fourth}1 ~>")
+        .s("sine")
+        .gain(0.7)
+        .lpf(120)
+        .attack(0.02)
+        .decay(0.3)
+        .sustain(0.6)
+        .release(0.8)
+        .room(0.3)`,
+            boom_bap: `note("<${safeKey}1 ~ ${safeKey}1 ~> <${safeKey}1 ${fourth}1 ~ ~> <${safeKey}1 ~ ${fifth}1 ~> <${fourth}1 ~ ${safeKey}1 ~>")
+        .s("sawtooth")
+        .gain(0.7)
+        .lpf(200)
+        .attack(0.01)
+        .decay(0.15)
+        .sustain(0.4)
+        .release(0.3)`
+        };
+        // Handle aliases
+        const styleMap = {
+            'liquid_dnb': 'intelligent_dnb',
+            'atmospheric_dnb': 'intelligent_dnb',
+            'intelligent': 'intelligent_dnb',
+            'liquid': 'intelligent_dnb',
+            'bukem': 'intelligent_dnb',
+            'triphop': 'trip_hop',
+            'portishead': 'trip_hop',
+            'massive_attack': 'trip_hop',
+            'boombap': 'boom_bap',
+            'golden_era': 'boom_bap',
+            'premier': 'boom_bap'
+        };
+        const resolvedStyle = styleMap[style.toLowerCase()] || style.toLowerCase();
+        return patterns[resolvedStyle] || patterns.techno;
+    }
+    /**
+     * Generates a melodic pattern from a scale
+     * @param scale - Array of note names to use
+     * @param length - Number of notes in the melody (default: 8)
+     * @param octaveRange - Tuple of min and max octave numbers (default: [3, 5])
+     * @returns Strudel melody pattern code
+     */
+    generateMelody(scale, length = 8, octaveRange = [3, 5]) {
+        const notes = [];
+        let lastNoteIndex = Math.floor(Math.random() * scale.length);
+        for (let i = 0; i < length; i++) {
+            // Create more musical intervals (prefer steps over leaps)
+            const stepProbability = 0.7;
+            const useStep = Math.random() < stepProbability;
+            let noteIndex;
+            if (useStep) {
+                // Move by step (1 or 2 scale degrees)
+                const step = Math.random() < 0.5 ? 1 : -1;
+                noteIndex = (lastNoteIndex + step + scale.length) % scale.length;
+            }
+            else {
+                // Leap to any note
+                noteIndex = Math.floor(Math.random() * scale.length);
+            }
+            const note = scale[noteIndex];
+            const octave = octaveRange[0] + Math.floor(Math.random() * (octaveRange[1] - octaveRange[0] + 1));
+            notes.push(`${note.toLowerCase()}${octave}`);
+            lastNoteIndex = noteIndex;
+        }
+        return `note("${notes.join(' ')}").s("triangle")`;
+    }
+    /**
+     * Generates a chord pattern from a progression
+     * @param progression - Chord progression string
+     * @param voicing - Chord voicing style (default: 'triad')
+     * @returns Strudel chord pattern code
+     */
+    generateChords(progression, voicing = 'triad') {
+        const voicings = {
+            triad: '.struct("1 ~ ~ ~")',
+            seventh: '.struct("1 ~ ~ ~").add(note("7"))',
+            sustained: '.attack(0.5).release(2)',
+            stab: '.struct("1 ~ 1 ~").release(0.1)',
+            pad: '.attack(2).release(4).room(0.8)'
+        };
+        return `note("<${progression}>").s("sawtooth")${voicings[voicing] || voicings.triad}`;
+    }
+    /**
+     * Generates a complete multi-layer musical pattern
+     * @param style - Music style (e.g., 'techno', 'house', 'jazz', 'ambient')
+     * @param key - Musical key (default: 'C')
+     * @param bpm - Tempo in beats per minute (default: 120)
+     * @returns Complete Strudel pattern with drums, bass, chords, and melody
+     */
+    generateCompletePattern(style, key = 'C', bpm = 120) {
+        // Handle aliases and special genres
+        const styleMap = {
+            'liquid_dnb': 'intelligent_dnb',
+            'atmospheric_dnb': 'intelligent_dnb',
+            'intelligent': 'intelligent_dnb',
+            'liquid': 'intelligent_dnb',
+            'atmospheric': 'intelligent_dnb',
+            'bukem': 'intelligent_dnb',
+            'triphop': 'trip_hop',
+            'portishead': 'trip_hop',
+            'massive_attack': 'trip_hop',
+            'flying_lotus': 'trip_hop',
+            'boombap': 'boom_bap',
+            'golden_era': 'boom_bap',
+            'premier': 'boom_bap',
+            'alchemist': 'boom_bap',
+            'daringer': 'boom_bap',
+            'hitboy': 'boom_bap'
+        };
+        const resolvedStyle = styleMap[style.toLowerCase()] || style.toLowerCase();
+        // Use specialized generators for new genres
+        switch (resolvedStyle) {
+            case 'intelligent_dnb':
+                return this.generateIntelligentDnB(key, bpm || 170);
+            case 'trip_hop':
+                return this.generateTripHop(key, bpm || 90);
+            case 'boom_bap':
+                return this.generateBoomBap(key, bpm || 92);
+        }
+        // Default generation for other styles
+        const drums = this.generateDrumPattern(resolvedStyle, 0.7);
+        const bass = this.generateBassline(key, resolvedStyle);
+        const scale = this.theory.generateScale(key, resolvedStyle === 'jazz' ? 'dorian' : 'minor');
+        const melody = this.generateMelody(scale);
+        const chordStyle = resolvedStyle === 'jazz' ? 'jazz' :
+            resolvedStyle === 'house' ? 'pop' :
+                resolvedStyle === 'techno' ? 'edm' : 'pop';
+        const progression = this.theory.generateChordProgression(key, chordStyle);
+        const chords = this.generateChords(progression, resolvedStyle === 'ambient' ? 'pad' : 'stab');
+        return `// ${resolvedStyle} pattern in ${key} at ${bpm} BPM
+setcpm(${bpm})
+
+stack(
+  // Drums
+  ${drums},
+  
+  // Bass
+  ${bass},
+  
+  // Chords
+  ${chords}.gain(0.6),
+  
+  // Melody
+  ${melody}.struct("~ 1 ~ 1 1 ~ 1 ~").delay(0.25).room(0.3).gain(0.5)
+).gain(0.8)`;
+    }
+    // ========================================
+    // INTELLIGENT DNB GENERATOR
+    // Style: LTJ Bukem, Good Looking Records
+    // ========================================
+    generateIntelligentDnB(key, tempo) {
+        const safeKey = key.toLowerCase();
+        const fourth = this.getFourth(safeKey);
+        const seventh = this.getMinorSeventh(safeKey);
+        const third = this.getMinorThird(safeKey);
+        return `// Intelligent DnB in ${key} at ${tempo} BPM
+// Style: LTJ Bukem / Good Looking Records
+setcps(${tempo}/60)
+samples('github:tidalcycles/dirt-samples')
+
+let chords = chord("<${safeKey}m9 ${fourth}m9 ${seventh}m9 ${third}maj7>/4").dict('ireal')
+
+stack(
+  // === DRUMS - Rolling break with ghost notes ===
+  s("breaks165")
+    .fit()
+    .slice(8, "0 0 6 3 0 2 6 7")
+    .gain(0.7)
+    .room(0.2),
+
+  // Ghost break layer
+  s("breaks165")
+    .fit()
+    .chop(16)
+    .gain(0.12)
+    .hpf(3000)
+    .room(0.4)
+    .pan(perlin.range(0.3, 0.7)),
+
+  // Kick reinforcement
+  s("bd ~ ~ ~ [~ bd] ~ bd ~")
+    .bank("RolandTR909")
+    .gain(0.45)
+    .lpf(100),
+
+  // Open hat accents
+  s("~ ~ ~ oh ~ ~ oh ~")
+    .bank("RolandTR909")
+    .gain(0.28)
+    .cut(1)
+    .room(0.35),
+
+  // === BASS - Deep sine sub ===
+  note("<${safeKey}1 ~ ${safeKey}1 ~> <${fourth}1 ~ ~ ${fourth}1> <${seventh}0 ~ ${seventh}0 ~> <${third}1 ~ ~ ~>")
+    .s("sine")
+    .gain(0.65)
+    .lpf(80)
+    .attack(0.01)
+    .decay(0.2)
+    .sustain(0.5)
+    .release(0.4),
+
+  // === CHORDS - Jazz voicings ===
+  chords.voicing()
+    .s("gm_epiano1")
+    .gain(0.3)
+    .room(0.5)
+    .delay(0.3)
+    .delaytime(0.375)
+    .delayfeedback(0.32)
+    .lpf(4500),
+
+  // === ATMOSPHERE - Ethereal strings ===
+  chords.voicing()
+    .s("gm_strings")
+    .attack(2)
+    .sustain(0.7)
+    .release(3)
+    .gain(0.18)
+    .room(0.7)
+    .size(0.85)
+    .lpf(3000)
+    .hpf(300)
+)`;
+    }
+    // ========================================
+    // TRIP HOP GENERATOR
+    // Style: Portishead, Massive Attack, Flying Lotus
+    // ========================================
+    generateTripHop(key, tempo) {
+        const safeKey = key.toLowerCase();
+        const fourth = this.getFourth(safeKey);
+        const fifth = this.getFifth(safeKey);
+        const seventh = this.getMinorSeventh(safeKey);
+        return `// Trip Hop in ${key} at ${tempo} BPM
+// Style: Portishead / Massive Attack
+setcps(${tempo}/60/2)
+
+stack(
+  // === DRUMS - Slow, heavy, dusty ===
+  
+  // Main beat - half time feel
+  s("bd ~ [~ bd] ~ bd ~ ~ ~")
+    .gain(0.85)
+    .lpf(150)
+    .room(0.3),
+
+  // Snare - heavy with room
+  s("~ ~ ~ ~ sd ~ ~ ~")
+    .bank("RolandTR808")
+    .gain(0.75)
+    .room(0.5)
+    .size(0.6),
+
+  // Ghost snares
+  s("~ ~ ~ sd:3? ~ ~ sd:2? ~")
+    .bank("RolandTR808")
+    .gain(0.2)
+    .room(0.4),
+
+  // Dusty hats
+  s("hh*8")
+    .gain(perlin.range(0.15, 0.3))
+    .hpf(5000)
+    .room(0.3)
+    .pan(perlin.range(0.3, 0.7).slow(4)),
+
+  // === BASS - Deep and moody ===
+  note("<${safeKey}1 ~ ~ ${safeKey}1> <~ ${fourth}1 ~ ~> <${fifth}1 ~ ${safeKey}1 ~> <~ ~ ${fourth}1 ~>")
+    .s("sine")
+    .gain(0.7)
+    .lpf(120)
+    .attack(0.02)
+    .decay(0.3)
+    .sustain(0.6)
+    .release(0.8)
+    .room(0.3),
+
+  // === KEYS - Dark Rhodes ===
+  chord("<${safeKey}m7 ${fourth}m7 ${fifth}m7 ${seventh}maj7>/4")
+    .dict('ireal')
+    .voicing()
+    .s("gm_epiano1")
+    .gain(0.25)
+    .room(0.5)
+    .lpf(2500)
+    .delay(0.4)
+    .delaytime(0.666)
+    .delayfeedback(0.35),
+
+  // === ATMOSPHERE - Dark pad ===
+  chord("<${safeKey}m7 ${fourth}m7>/8")
+    .dict('ireal')
+    .voicing()
+    .s("sawtooth")
+    .attack(3)
+    .sustain(0.6)
+    .release(4)
+    .lpf(sine.range(300, 800).slow(16))
+    .lpq(0.5)
+    .gain(0.12)
+    .room(0.8)
+    .size(0.9),
+
+  // === TEXTURE - Vinyl crackle vibe ===
+  s("hh:8*16")
+    .gain(0.03)
+    .hpf(8000)
+    .room(0.2)
+)`;
+    }
+    // ========================================
+    // BOOM BAP GENERATOR
+    // Style: DJ Premier, Alchemist, Daringer, Hit-Boy
+    // ========================================
+    generateBoomBap(key, tempo) {
+        const safeKey = key.toLowerCase();
+        const fourth = this.getFourth(safeKey);
+        const fifth = this.getFifth(safeKey);
+        const seventh = this.getMinorSeventh(safeKey);
+        const minorThird = this.getMinorThird(safeKey);
+        return `// Boom Bap in ${key} at ${tempo} BPM
+// Style: DJ Premier / Alchemist / Daringer
+setcps(${tempo}/60/2)
+
+stack(
+  // === DRUMS - Hard hitting, swing ===
+  
+  // Main kick pattern
+  s("bd ~ ~ [~ bd] sd ~ ~ ~, bd ~ ~ bd sd ~ [bd bd] ~")
+    .gain(0.9)
+    .lpf(200)
+    .room(0.15),
+
+  // Layered snare for crack
+  s("~ ~ ~ ~ sd:3 ~ ~ ~")
+    .gain(0.35)
+    .hpf(200)
+    .room(0.25),
+
+  // Crispy hats
+  s("[~ hh]*8")
+    .gain(0.5)
+    .hpf(4000)
+    .room(0.2),
+
+  // Open hat accents
+  s("~ ~ oh ~ ~ ~ ~ oh:2")
+    .gain(0.3)
+    .room(0.35)
+    .cut(1),
+
+  // === BASS - Punchy and warm ===
+  note("<${safeKey}1 ~ ${safeKey}1 ~> <${safeKey}1 ${fourth}1 ~ ~> <${safeKey}1 ~ ${fifth}1 ~> <${fourth}1 ~ ${safeKey}1 ~>")
+    .s("sawtooth")
+    .gain(0.65)
+    .lpf(180)
+    .attack(0.01)
+    .decay(0.15)
+    .sustain(0.4)
+    .release(0.3),
+
+  // === CHOPS - Soul sample style ===
+  chord("<${safeKey}m7 ~ ${fourth}m7 ~> <${seventh}maj7 ~ ${minorThird}maj7 ~>/2")
+    .dict('ireal')
+    .voicing()
+    .s("gm_epiano1")
+    .gain(0.4)
+    .room(0.3)
+    .lpf(3000)
+    .hpf(200),
+
+  // === STRINGS - Cinematic stabs ===
+  chord("<${safeKey}m7 ~ ~ ~> <~ ~ ${fourth}m7 ~>/4")
+    .dict('ireal')
+    .voicing()
+    .s("gm_strings")
+    .struct("1 ~ ~ ~ ~ 1? ~ ~")
+    .attack(0.1)
+    .release(0.8)
+    .gain(0.25)
+    .room(0.4)
+    .lpf(4000)
+    .hpf(300),
+
+  // === HORNS - Optional stab ===
+  note("<${safeKey}4 ${minorThird}4 ${fourth}4 ${safeKey}4>/8")
+    .s("gm_brass")
+    .struct("~ ~ ~ ~ 1 ~ ~ ~")
+    .gain(0.2)
+    .room(0.3)
+    .lpf(3500)
+).swing(0.08)`;
+    }
+    /**
+     * Generates variations on an existing pattern
+     * @param pattern - Original pattern code
+     * @param variationType - Type of variation ('subtle', 'moderate', 'extreme', 'glitch', 'evolving')
+     * @returns Pattern with variation modifiers applied
+     */
+    generateVariation(pattern, variationType = 'subtle') {
+        const variations = {
+            subtle: '.sometimes(x => x.fast(2))',
+            moderate: '.every(4, x => x.rev).sometimes(x => x.fast(2))',
+            extreme: '.every(2, x => x.jux(rev)).sometimes(x => x.iter(4))',
+            glitch: '.sometimes(x => x.chop(8).rev).rarely(x => x.speed(-1))',
+            evolving: '.slow(4).every(8, x => x.fast(2)).every(16, x => x.palindrome)'
+        };
+        return pattern + (variations[variationType] || variations.subtle);
+    }
+    /**
+     * Generates a drum fill for transitions
+     * @param style - Music style for the fill
+     * @param bars - Length of the fill in bars (default: 1)
+     * @returns Strudel fill pattern code
+     */
+    generateFill(style, bars = 1) {
+        const fills = {
+            techno: `s("bd*8, cp*4").fast(${bars})`,
+            house: `s("bd*4, cp*2, hh*16").fast(${bars})`,
+            dnb: `s("bd*8, sn*8").fast(${bars * 2})`,
+            trap: `s("bd*4, hh*32").fast(${bars})`,
+            breakbeat: `s("bd cp bd cp, hh*8").iter(4).fast(${bars})`,
+            intelligent_dnb: `s("breaks165").fit().slice(16, "0 2 4 6 8 10 12 14 1 3 5 7 9 11 13 15").gain(0.7).fast(${bars})`,
+            trip_hop: `s("bd ~ sd ~, hh*4").room(0.5).fast(${bars})`,
+            boom_bap: `s("bd sd bd sd, hh*8").swing(0.1).fast(${bars})`
+        };
+        return fills[style] || fills.techno;
+    }
+    /**
+     * Generates a transition between two musical styles
+     * @param fromStyle - Starting music style
+     * @param toStyle - Target music style
+     * @param bars - Length of transition in bars (default: 4)
+     * @returns Strudel transition pattern with crossfade
+     */
+    generateTransition(fromStyle, toStyle, bars = 4) {
+        return `// Transition from ${fromStyle} to ${toStyle}
+stack(
+  // Fade out ${fromStyle}
+  ${this.generateDrumPattern(fromStyle, 0.5)}.gain(perlin.range(0.8, 0).slow(${bars})),
+  
+  // Fade in ${toStyle}
+  ${this.generateDrumPattern(toStyle, 0.5)}.gain(perlin.range(0, 0.8).slow(${bars}))
+)`;
+    }
+    /**
+     * Generates a Euclidean rhythm pattern
+     * @param hits - Number of hits in the pattern
+     * @param steps - Total number of steps
+     * @param sound - Sound name to use (default: "bd")
+     * @returns Strudel Euclidean pattern code
+     */
+    generateEuclideanPattern(hits, steps, sound = "bd") {
+        const rhythm = this.theory.generateEuclideanRhythm(hits, steps);
+        return `s("${sound}").struct("${rhythm}")`;
+    }
+    /**
+     * Generates a polyrhythmic pattern with multiple Euclidean rhythms
+     * @param sounds - Array of sound names to use
+     * @param patterns - Array of hit counts for each rhythm
+     * @returns Strudel polyrhythm pattern code
+     * @throws {Error} When sounds and patterns arrays have different lengths
+     */
+    generatePolyrhythm(sounds, patterns) {
+        if (sounds.length !== patterns.length) {
+            throw new Error('Number of sounds must match number of patterns');
+        }
+        const rhythms = sounds.map((sound, i) => {
+            return `s("${sound}").euclid(${patterns[i]}, 16)`;
+        });
+        return `stack(\n  ${rhythms.join(',\n  ')}\n)`;
+    }
+}