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

package/dist/services/PatternGenerator.js

@@ -1,4 +1,10 @@
 import { MusicTheory } from './MusicTheory.js';
+import { STYLE_ALIASES, resolveDrumStyle, defaultTempoFor } from './StyleRegistry.js';
+import { lookup } from '../utils/TableLookup.js';
+import { ValidationError } from '../utils/CategorisedError.js';
+import { BEATS_PER_CYCLE } from '../utils/Tempo.js';
+/** Longest fill this will assemble, so `bars` cannot build a huge string. */
+const MAX_FILL_BARS = 64;
 export class PatternGenerator {
     theory = new MusicTheory();
     // Note interval lookup for chord calculations
@@ -7,15 +13,26 @@ export class PatternGenerator {
      * Get a note at a specific interval from the root
      */
     getInterval(root, semitones) {
-        const normalizedRoot = root.toLowerCase().replace('#', 'b');
+        // The `.replace('#','b')` used to run BEFORE this lookup, so its
+        // keys could never match — dead code. 'c#' became 'cb', which is not
+        // in `notes`, so the root came back unchanged; 'd#' became 'db',
+        // which IS in `notes` but is the wrong note, a semitone flat. So
+        // getFifth('D#') returned 'ab' and getFifth('F#') returned 'F#',
+        // while MusicTheory.getNote got the same intervals right (#318).
+        const lower = root.toLowerCase();
         const sharpToFlat = {
-            'c#': 'db', 'd#': 'eb', 'f#': 'gb', 'g#': 'ab', 'a#': 'bb'
+            'c#': 'db', 'd#': 'eb', 'f#': 'gb', 'g#': 'ab', 'a#': 'bb',
+            // Enharmonics that are not in `notes` but are legal input.
+            'e#': 'f', 'b#': 'c', 'cb': 'b', 'fb': 'e',
         };
-        const searchRoot = sharpToFlat[normalizedRoot] || normalizedRoot;
+        const searchRoot = Object.hasOwn(sharpToFlat, lower) ? sharpToFlat[lower] : lower;
         const idx = this.notes.indexOf(searchRoot);
         if (idx === -1)
             return root;
-        return this.notes[(idx + semitones) % 12];
+        // Modulo alone goes negative for a negative interval; none are used
+        // today, but the guard costs nothing and the bug it prevents is the
+        // same shape as the one above.
+        return this.notes[(((idx + semitones) % 12) + 12) % 12];
     }
     getFourth(root) { return this.getInterval(root, 5); }
     getFifth(root) { return this.getInterval(root, 7); }
@@ -119,26 +136,15 @@ export class PatternGenerator {
             ]
         };
         // 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;
+        // hasOwn, not `??`: STYLE_ALIASES is a plain object literal, so
+        // STYLE_ALIASES['constructor'] returns Object and ['__proto__'] the
+        // prototype. Neither is nullish, so `??` never fired and the result
+        // was used as a string — TypeError, categorised `internal` (#295).
+        const lowerStyle = String(style ?? '').toLowerCase();
+        const resolvedStyle = Object.hasOwn(STYLE_ALIASES, lowerStyle)
+            ? STYLE_ALIASES[lowerStyle]
+            : lowerStyle;
+        const stylePatterns = lookup(patterns, resolvedStyle, patterns.techno);
         const index = Math.min(Math.floor(complexity * stylePatterns.length), stylePatterns.length - 1);
         return stylePatterns[index];
     }
@@ -190,21 +196,15 @@ export class PatternGenerator {
         .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;
+        // hasOwn, not `??`: STYLE_ALIASES is a plain object literal, so
+        // STYLE_ALIASES['constructor'] returns Object and ['__proto__'] the
+        // prototype. Neither is nullish, so `??` never fired and the result
+        // was used as a string — TypeError, categorised `internal` (#295).
+        const lowerStyle = String(style ?? '').toLowerCase();
+        const resolvedStyle = Object.hasOwn(STYLE_ALIASES, lowerStyle)
+            ? STYLE_ALIASES[lowerStyle]
+            : lowerStyle;
+        return lookup(patterns, resolvedStyle, patterns.techno);
     }
     /**
      * Generates a melodic pattern from a scale
@@ -222,7 +222,8 @@ export class PatternGenerator {
             const useStep = Math.random() < stepProbability;
             let noteIndex;
             if (useStep) {
-                // Move by step (1 or 2 scale degrees)
+                // One scale degree, up or down. The comment used to claim "1 or
+                // 2" while the code only ever moved by 1 (#324).
                 const step = Math.random() < 0.5 ? 1 : -1;
                 noteIndex = (lastNoteIndex + step + scale.length) % scale.length;
             }
@@ -246,12 +247,20 @@ export class PatternGenerator {
     generateChords(progression, voicing = 'triad') {
         const voicings = {
             triad: '.struct("1 ~ ~ ~")',
+            // `.add(note("7"))` transposes every note of the chord up 7
+            // semitones — a perfect FIFTH, not a seventh. Strudel spells a
+            // seventh chord in the chord symbol itself, so the honest fix is
+            // to stop pretending this voicing adds one: it is a fifth-doubled
+            // stab, and is now named for what it does. `seventh` is kept as
+            // an alias so existing callers do not break, but it maps to the
+            // same thing rather than to a lie (#324).
+            fifths: '.struct("1 ~ ~ ~").add(note("7"))',
             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}`;
+        return `note("<${progression}>").s("sawtooth")${lookup(voicings, voicing, voicings.triad)}`;
     }
     /**
      * Generates a complete multi-layer musical pattern
@@ -260,48 +269,73 @@ export class PatternGenerator {
      * @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) {
+    generateCompletePattern(style, key = 'C', bpm) {
         // 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();
+        // hasOwn, not `??`: STYLE_ALIASES is a plain object literal, so
+        // STYLE_ALIASES['constructor'] returns Object and ['__proto__'] the
+        // prototype. Neither is nullish, so `??` never fired and the result
+        // was used as a string — TypeError, categorised `internal` (#295).
+        const lowerStyle = String(style ?? '').toLowerCase();
+        const resolvedStyle = Object.hasOwn(STYLE_ALIASES, lowerStyle)
+            ? STYLE_ALIASES[lowerStyle]
+            : lowerStyle;
+        // The style's own tempo when the caller did not name one.
+        //
+        // The parameter defaulted to 120, so `bpm || 170` below could never
+        // reach 170 — `bpm` was never falsy. Every per-style fallback here
+        // was dead code and every specialized genre generated at 120:
+        // intelligent_dnb at 120 rather than 170, trip_hop at 120 rather
+        // than 90, boom_bap at 120 rather than 92, and plain techno at 120
+        // rather than 130.
+        //
+        // `compose` passes `defaultTempoFor(style)` explicitly, so the
+        // shipped tool path was already right and only direct callers saw
+        // this. Reading the same registry here makes the two agree instead
+        // of relying on every caller to remember (#482).
+        const tempo = bpm ?? defaultTempoFor(resolvedStyle);
         // Use specialized generators for new genres
         switch (resolvedStyle) {
             case 'intelligent_dnb':
-                return this.generateIntelligentDnB(key, bpm || 170);
+                return this.generateIntelligentDnB(key, tempo);
             case 'trip_hop':
-                return this.generateTripHop(key, bpm || 90);
+                return this.generateTripHop(key, tempo);
             case 'boom_bap':
-                return this.generateBoomBap(key, bpm || 92);
+                return this.generateBoomBap(key, tempo);
         }
         // 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);
+        // Melody scale and chord progression must agree on mode.
+        //
+        // The scale was hardcoded to `minor` for everything except jazz,
+        // while house / ambient / default got the `pop` progression — a
+        // major I-V-vi-IV. So house in C produced <C G Am F> under a melody
+        // of g#3 d#4 f4 c5 …, sounding Ab and Eb over C major and F major
+        // triads (#324). Pick the progression first, then take the scale
+        // that belongs to it.
         const chordStyle = resolvedStyle === 'jazz' ? 'jazz' :
             resolvedStyle === 'house' ? 'pop' :
                 resolvedStyle === 'techno' ? 'edm' : 'pop';
+        const scaleForChords = {
+            jazz: 'major',
+            pop: 'major',
+            edm: 'minor',
+            modal: 'minor',
+        };
+        const scale = this.theory.generateScale(key, lookup(scaleForChords, chordStyle, 'minor'));
+        const melody = this.generateMelody(scale);
         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})
+        // The header names what the drums actually are. `resolvedStyle` is
+        // only alias-resolved, so an unknown genre stamped its own name over
+        // a techno pattern (#279).
+        const drumStyle = resolveDrumStyle(resolvedStyle);
+        const header = drumStyle.supported
+            ? `// ${drumStyle.resolved} pattern in ${key} at ${tempo} BPM`
+            : `// ${drumStyle.resolved} pattern in ${key} at ${tempo} BPM` +
+                ` (no drums defined for "${resolvedStyle}")`;
+        return `${header}
+setcpm(${tempo}/${String(BEATS_PER_CYCLE)})
 
 stack(
   // Drums
@@ -328,7 +362,7 @@ stack(
         const third = this.getMinorThird(safeKey);
         return `// Intelligent DnB in ${key} at ${tempo} BPM
 // Style: LTJ Bukem / Good Looking Records
-setcps(${tempo}/60)
+setcpm(${tempo}/${String(BEATS_PER_CYCLE)})
 samples('github:tidalcycles/dirt-samples')
 
 let chords = chord("<${safeKey}m9 ${fourth}m9 ${seventh}m9 ${third}maj7>/4").dict('ireal')
@@ -407,7 +441,7 @@ stack(
         const seventh = this.getMinorSeventh(safeKey);
         return `// Trip Hop in ${key} at ${tempo} BPM
 // Style: Portishead / Massive Attack
-setcps(${tempo}/60/2)
+setcpm(${tempo}/${String(BEATS_PER_CYCLE)})
 
 stack(
   // === DRUMS - Slow, heavy, dusty ===
@@ -494,7 +528,7 @@ stack(
         const minorThird = this.getMinorThird(safeKey);
         return `// Boom Bap in ${key} at ${tempo} BPM
 // Style: DJ Premier / Alchemist / Daringer
-setcps(${tempo}/60/2)
+setcpm(${tempo}/${String(BEATS_PER_CYCLE)})
 
 stack(
   // === DRUMS - Hard hitting, swing ===
@@ -573,13 +607,27 @@ stack(
      */
     generateVariation(pattern, variationType = 'subtle') {
         const variations = {
+            // `.rev` and `.palindrome` need their CALL PARENTHESES.
+            //
+            // `pattern.rev` is a function, not a Pattern, so `every(4, x =>
+            // x.rev)` hands Strudel a function where it wants a pattern.
+            // Measured against @strudel/core, on the cycles where the
+            // transform applies:
+            //
+            //   sequence(pure('bd'), pure('sd'))          -> "bd"@0 "sd"@0.5
+            //   .every(4, x => x.rev)                     -> undefined@0
+            //   .every(4, x => x.rev())                   -> "bd"@0.5 "sd"@0
+            //
+            // One valueless event in place of the music, every fourth cycle,
+            // and it throws nothing — so a pattern that looks right goes
+            // partly silent (#482).
             subtle: '.sometimes(x => x.fast(2))',
-            moderate: '.every(4, x => x.rev).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)'
+            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);
+        return pattern + lookup(variations, variationType, variations.subtle);
     }
     /**
      * Generates a drum fill for transitions
@@ -588,17 +636,52 @@ stack(
      * @returns Strudel fill pattern code
      */
     generateFill(style, bars = 1) {
+        // One BAR of material per style. `bars` assembles them below.
         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})`
+            techno: 's("bd*8, cp*4")',
+            house: 's("bd*4, cp*2, hh*16")',
+            // dnb's fill is double-time by character, not by bar count.
+            dnb: 's("bd*8, sn*8").fast(2)',
+            trap: 's("bd*4, hh*32")',
+            breakbeat: 's("bd cp bd cp, hh*8").iter(4)',
+            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)',
+            trip_hop: 's("bd ~ sd ~, hh*4").room(0.5)',
+            boom_bap: 's("bd sd bd sd, hh*8").swing(0.1)',
         };
-        return fills[style] || fills.techno;
+        // Resolve the style the same way every other generator does.
+        //
+        // `lookup` is an exact-key match, so this alone saw neither the
+        // alias table nor a capital letter: `generateFill('triphop')` and
+        // `generateFill('House')` both fell through to the techno fill,
+        // while `generateDrumPattern` resolved both correctly (#482).
+        const lowerStyle = String(style ?? '').toLowerCase();
+        const resolvedStyle = Object.hasOwn(STYLE_ALIASES, lowerStyle)
+            ? STYLE_ALIASES[lowerStyle]
+            : lowerStyle;
+        const base = lookup(fills, resolvedStyle, fills.techno);
+        // `bars` is a LENGTH, which is what the tool schema promises and
+        // what the handler's "Generated N bar fill" message claims.
+        //
+        // It used to append `.fast(bars)`. In Strudel that compresses the
+        // pattern into 1/N of ONE cycle and repeats it N times inside that
+        // cycle, so asking for more bars made the fill shorter and denser
+        // and the output occupied one bar however large `bars` got. The
+        // schema and the message were both false for any bars != 1, and
+        // the unit test asserted the literal text `.fast(2)` — locking in
+        // the implementation rather than any intended behaviour, the exact
+        // anti-pattern the tempo postmortem warns about (#482).
+        //
+        // `cat` takes one cycle per argument, measured:
+        //
+        //   cat(a, a, a, b)  ->  cycle 0: a   1: a   2: a   3: b   4: a
+        //
+        // so N bars is N arguments, and the last one is the base at double
+        // time — the ordinary way a fill builds into the next phrase.
+        const count = Number.isInteger(bars) && bars > 1 ? Math.min(bars, MAX_FILL_BARS) : 1;
+        if (count === 1)
+            return base;
+        const earlier = new Array(count - 1).fill(base);
+        return `cat(${[...earlier, `${base}.fast(2)`].join(', ')})`;
     }
     /**
      * Generates a transition between two musical styles
@@ -637,7 +720,7 @@ stack(
      */
     generatePolyrhythm(sounds, patterns) {
         if (sounds.length !== patterns.length) {
-            throw new Error('Number of sounds must match number of patterns');
+            throw new ValidationError('Number of sounds must match number of patterns');
         }
         const rhythms = sounds.map((sound, i) => {
             return `s("${sound}").euclid(${patterns[i]}, 16)`;