@williamzujkowski/live-coding-music-mcp 1.0.0

package/dist/services/MIDIExportService.js

@@ -0,0 +1,412 @@
+/**
+ * MIDI Export Service
+ *
+ * Converts Strudel patterns to MIDI files using @tonejs/midi.
+ * Parses note() functions, MIDI numbers, and chord names from patterns.
+ *
+ * @example
+ * const service = new MIDIExportService();
+ * const notes = service.parsePatternNotes('note("c4 e4 g4")');
+ * const midi = service.convertToMidi(notes, { bpm: 120 });
+ * const base64 = service.exportToBase64(midi);
+ */
+// @tonejs/midi is CommonJS - use dynamic import approach
+import * as midiModule from '@tonejs/midi';
+// Handle both ESM and CJS interop
+const Midi = midiModule.Midi || midiModule.default?.Midi;
+import { writeFileSync } from 'fs';
+import { resolve } from 'path';
+/**
+ * Note name to MIDI number mapping.
+ * C4 = 60 (middle C)
+ */
+const NOTE_NAMES = {
+    'c': 0, 'c#': 1, 'db': 1,
+    'd': 2, 'd#': 3, 'eb': 3,
+    'e': 4, 'fb': 4, 'e#': 5,
+    'f': 5, 'f#': 6, 'gb': 6,
+    'g': 7, 'g#': 8, 'ab': 8,
+    'a': 9, 'a#': 10, 'bb': 10,
+    'b': 11, 'cb': 11, 'b#': 0
+};
+/**
+ * Chord intervals from root note.
+ * Used to expand chord names to individual notes.
+ */
+const CHORD_INTERVALS = {
+    '': [0, 4, 7], // major
+    'm': [0, 3, 7], // minor
+    '7': [0, 4, 7, 10], // dominant 7
+    'maj7': [0, 4, 7, 11], // major 7
+    'm7': [0, 3, 7, 10], // minor 7
+    'dim': [0, 3, 6], // diminished
+    'aug': [0, 4, 8], // augmented
+    'dim7': [0, 3, 6, 9], // diminished 7
+    'sus2': [0, 2, 7], // suspended 2
+    'sus4': [0, 5, 7], // suspended 4
+    '9': [0, 4, 7, 10, 14], // dominant 9
+    'maj9': [0, 4, 7, 11, 14], // major 9
+    'm9': [0, 3, 7, 10, 14], // minor 9
+    'add9': [0, 4, 7, 14], // add 9
+    '6': [0, 4, 7, 9], // major 6
+    'm6': [0, 3, 7, 9] // minor 6
+};
+export class MIDIExportService {
+    /**
+     * Converts a note name (e.g., "C4", "D#5", "Bb3") to MIDI number
+     * @param noteName - Note name with optional accidental and octave
+     * @returns MIDI note number (0-127) or null if invalid
+     */
+    noteNameToMidi(noteName) {
+        if (!noteName || typeof noteName !== 'string') {
+            return null;
+        }
+        const cleaned = noteName.toLowerCase().trim();
+        // Check for pure MIDI number
+        const midiNum = parseInt(cleaned, 10);
+        if (!isNaN(midiNum) && midiNum >= 0 && midiNum <= 127 && cleaned === midiNum.toString()) {
+            return midiNum;
+        }
+        // Parse note name with regex
+        // Matches: c, c#, db, c4, c#4, db4, etc.
+        const match = cleaned.match(/^([a-g])([#b]?)(-?\d+)?$/);
+        if (!match) {
+            return null;
+        }
+        const [, letter, accidental, octaveStr] = match;
+        const noteKey = letter + (accidental || '');
+        const semitone = NOTE_NAMES[noteKey];
+        if (semitone === undefined) {
+            return null;
+        }
+        // Default octave is 4 (middle C area)
+        const octave = octaveStr !== undefined ? parseInt(octaveStr, 10) : 4;
+        // MIDI note = (octave + 1) * 12 + semitone
+        // C4 = 60, so octave 4 base = 60, but 60 = (4+1)*12 + 0
+        const midi = (octave + 1) * 12 + semitone;
+        // Clamp to valid MIDI range
+        if (midi < 0 || midi > 127) {
+            return null;
+        }
+        return midi;
+    }
+    /**
+     * Converts a MIDI number to note name
+     * @param midi - MIDI note number (0-127)
+     * @returns Note name with octave (e.g., "C4")
+     */
+    midiToNoteName(midi) {
+        const noteNames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+        const octave = Math.floor(midi / 12) - 1;
+        const note = noteNames[midi % 12];
+        return `${note}${octave}`;
+    }
+    /**
+     * Expands a chord name to individual MIDI note numbers
+     * @param chordName - Chord name (e.g., "Cmaj7", "Am", "G7")
+     * @param octave - Base octave (default: 4)
+     * @returns Array of MIDI note numbers or empty array if invalid
+     */
+    expandChord(chordName, octave = 4) {
+        if (!chordName || typeof chordName !== 'string') {
+            return [];
+        }
+        const cleaned = chordName.trim();
+        // Parse chord: root note + optional accidental + chord type
+        const match = cleaned.match(/^([A-Ga-g])([#b]?)(.*)$/);
+        if (!match) {
+            return [];
+        }
+        const [, letter, accidental, chordType] = match;
+        const rootKey = letter.toLowerCase() + (accidental || '');
+        const rootSemitone = NOTE_NAMES[rootKey];
+        if (rootSemitone === undefined) {
+            return [];
+        }
+        // Get chord intervals, default to major triad
+        const intervals = CHORD_INTERVALS[chordType.toLowerCase()] || CHORD_INTERVALS[''];
+        const rootMidi = (octave + 1) * 12 + rootSemitone;
+        return intervals.map(interval => {
+            const midi = rootMidi + interval;
+            return midi >= 0 && midi <= 127 ? midi : -1;
+        }).filter(n => n >= 0);
+    }
+    /**
+     * Parses a Strudel pattern and extracts note events
+     * @param pattern - Strudel pattern code
+     * @returns Array of NoteEvent objects
+     */
+    parsePatternNotes(pattern) {
+        if (!pattern || typeof pattern !== 'string') {
+            return [];
+        }
+        const notes = [];
+        let currentTime = 0;
+        // Extract note() function calls
+        // Matches: note("c4 e4 g4"), note("c4", "e4"), note(`c4`)
+        const noteRegex = /note\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi;
+        let noteMatch;
+        while ((noteMatch = noteRegex.exec(pattern)) !== null) {
+            const noteContent = noteMatch[1];
+            const parsedNotes = this.parseNoteString(noteContent, currentTime);
+            notes.push(...parsedNotes);
+            currentTime += parsedNotes.length > 0 ? 1 : 0;
+        }
+        // Extract n() function calls (Strudel shorthand)
+        const nRegex = /\bn\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi;
+        let nMatch;
+        while ((nMatch = nRegex.exec(pattern)) !== null) {
+            const noteContent = nMatch[1];
+            // n() uses MIDI numbers directly
+            const parsedNotes = this.parseNoteString(noteContent, currentTime, true);
+            notes.push(...parsedNotes);
+            currentTime += parsedNotes.length > 0 ? 1 : 0;
+        }
+        // Extract chord patterns
+        const chordRegex = /chord\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi;
+        let chordMatch;
+        while ((chordMatch = chordRegex.exec(pattern)) !== null) {
+            const chordContent = chordMatch[1];
+            const parsedChords = this.parseChordString(chordContent, currentTime);
+            notes.push(...parsedChords);
+            currentTime += parsedChords.length > 0 ? 1 : 0;
+        }
+        // Extract s() sound patterns with n() modifier for samples
+        // e.g., s("piano").n("0 2 4 7")
+        const soundNRegex = /s\s*\([^)]+\)\s*\.n\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi;
+        let soundNMatch;
+        while ((soundNMatch = soundNRegex.exec(pattern)) !== null) {
+            const noteContent = soundNMatch[1];
+            const parsedNotes = this.parseNoteString(noteContent, currentTime, true);
+            notes.push(...parsedNotes);
+            currentTime += parsedNotes.length > 0 ? 1 : 0;
+        }
+        // If no notes found through function parsing, try to find inline notes
+        if (notes.length === 0) {
+            const inlineNotes = this.parseInlineNotes(pattern);
+            notes.push(...inlineNotes);
+        }
+        return notes;
+    }
+    /**
+     * Parses a space/comma-separated note string
+     * @param noteString - String of notes (e.g., "c4 e4 g4" or "60 64 67")
+     * @param startTime - Starting time in beats
+     * @param asMidiNumbers - Treat values as MIDI numbers
+     * @returns Array of NoteEvent objects
+     */
+    parseNoteString(noteString, startTime, asMidiNumbers = false) {
+        const notes = [];
+        const parts = noteString.split(/[\s,]+/).filter(p => p.length > 0);
+        const noteDuration = parts.length > 0 ? 1 / parts.length : 1;
+        parts.forEach((part, index) => {
+            // Check for rest
+            if (part === '~' || part === '-' || part === 'r') {
+                return;
+            }
+            // Handle sub-patterns in brackets [c4 e4]
+            if (part.startsWith('[')) {
+                const subContent = part.replace(/[\[\]]/g, '');
+                const subParts = subContent.split(/[\s,]+/);
+                subParts.forEach(subPart => {
+                    const midi = asMidiNumbers
+                        ? parseInt(subPart, 10)
+                        : this.noteNameToMidi(subPart);
+                    if (midi !== null && !isNaN(midi) && midi >= 0 && midi <= 127) {
+                        notes.push({
+                            note: midi,
+                            time: startTime + index * noteDuration,
+                            duration: noteDuration / subParts.length,
+                            velocity: 100
+                        });
+                    }
+                });
+                return;
+            }
+            const midi = asMidiNumbers
+                ? parseInt(part, 10)
+                : this.noteNameToMidi(part);
+            if (midi !== null && !isNaN(midi) && midi >= 0 && midi <= 127) {
+                notes.push({
+                    note: midi,
+                    time: startTime + index * noteDuration,
+                    duration: noteDuration,
+                    velocity: 100
+                });
+            }
+        });
+        return notes;
+    }
+    /**
+     * Parses a chord string and expands to note events
+     * @param chordString - String of chord names (e.g., "Cmaj7 Am Dm G7")
+     * @param startTime - Starting time in beats
+     * @returns Array of NoteEvent objects
+     */
+    parseChordString(chordString, startTime) {
+        const notes = [];
+        const chords = chordString.split(/[\s,]+/).filter(c => c.length > 0);
+        const chordDuration = chords.length > 0 ? 1 / chords.length : 1;
+        chords.forEach((chord, index) => {
+            if (chord === '~' || chord === '-' || chord === 'r') {
+                return;
+            }
+            const midiNotes = this.expandChord(chord);
+            midiNotes.forEach(midi => {
+                notes.push({
+                    note: midi,
+                    time: startTime + index * chordDuration,
+                    duration: chordDuration,
+                    velocity: 100
+                });
+            });
+        });
+        return notes;
+    }
+    /**
+     * Attempts to find note-like patterns inline in the pattern code
+     * @param pattern - Full pattern string
+     * @returns Array of NoteEvent objects
+     */
+    parseInlineNotes(pattern) {
+        const notes = [];
+        // Find quoted strings that look like note sequences
+        const quotedRegex = /["'`]([a-g][#b]?\d[\s,a-g#b0-9~\-\[\]]+)["'`]/gi;
+        let match;
+        while ((match = quotedRegex.exec(pattern)) !== null) {
+            const noteSequence = match[1];
+            const parsed = this.parseNoteString(noteSequence, notes.length);
+            notes.push(...parsed);
+        }
+        return notes;
+    }
+    /**
+     * Converts parsed note events to a MIDI object
+     * @param notes - Array of NoteEvent objects
+     * @param options - MIDI export options
+     * @returns Midi object
+     */
+    convertToMidi(notes, options = {}) {
+        const { bpm = 120, bars = 4, trackName = 'Strudel Pattern', timeSignatureNumerator = 4, timeSignatureDenominator = 4 } = options;
+        const midi = new Midi();
+        // Set tempo
+        midi.header.setTempo(bpm);
+        // Set time signature
+        midi.header.timeSignatures.push({
+            ticks: 0,
+            timeSignature: [timeSignatureNumerator, timeSignatureDenominator],
+            measures: 0
+        });
+        // Create track
+        const track = midi.addTrack();
+        track.name = trackName;
+        // Calculate PPQ (pulses per quarter note) from the header
+        const ppq = midi.header.ppq;
+        // Add notes to track
+        notes.forEach(noteEvent => {
+            // Only add notes within the specified bar range
+            const maxTime = bars * timeSignatureNumerator;
+            if (noteEvent.time >= maxTime) {
+                return;
+            }
+            // Convert beat time to seconds at the given BPM
+            const timeInSeconds = (noteEvent.time / (bpm / 60));
+            const durationInSeconds = (noteEvent.duration / (bpm / 60));
+            track.addNote({
+                midi: noteEvent.note,
+                time: timeInSeconds,
+                duration: durationInSeconds,
+                velocity: noteEvent.velocity / 127
+            });
+        });
+        return midi;
+    }
+    /**
+     * Exports a Strudel pattern to a MIDI file
+     * @param pattern - Strudel pattern code
+     * @param filename - Output filename (default: 'pattern.mid')
+     * @param options - MIDI export options
+     * @returns Export result
+     */
+    exportToFile(pattern, filename = 'pattern.mid', options = {}) {
+        try {
+            const notes = this.parsePatternNotes(pattern);
+            if (notes.length === 0) {
+                return {
+                    success: false,
+                    output: '',
+                    noteCount: 0,
+                    bars: options.bars || 4,
+                    bpm: options.bpm || 120,
+                    error: 'No notes found in pattern. Use note(), n(), or chord() functions.'
+                };
+            }
+            const midi = this.convertToMidi(notes, options);
+            // Ensure filename has .mid extension
+            const finalFilename = filename.endsWith('.mid') ? filename : `${filename}.mid`;
+            const outputPath = resolve(finalFilename);
+            // Write MIDI data
+            const midiArray = midi.toArray();
+            writeFileSync(outputPath, Buffer.from(midiArray));
+            return {
+                success: true,
+                output: outputPath,
+                noteCount: notes.length,
+                bars: options.bars || 4,
+                bpm: options.bpm || 120
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: '',
+                noteCount: 0,
+                bars: options.bars || 4,
+                bpm: options.bpm || 120,
+                error: `MIDI export failed: ${error.message}`
+            };
+        }
+    }
+    /**
+     * Exports a Strudel pattern to base64-encoded MIDI data
+     * @param pattern - Strudel pattern code
+     * @param options - MIDI export options
+     * @returns Export result with base64 data
+     */
+    exportToBase64(pattern, options = {}) {
+        try {
+            const notes = this.parsePatternNotes(pattern);
+            if (notes.length === 0) {
+                return {
+                    success: false,
+                    output: '',
+                    noteCount: 0,
+                    bars: options.bars || 4,
+                    bpm: options.bpm || 120,
+                    error: 'No notes found in pattern. Use note(), n(), or chord() functions.'
+                };
+            }
+            const midi = this.convertToMidi(notes, options);
+            const midiArray = midi.toArray();
+            const buffer = Buffer.from(midiArray);
+            const base64 = buffer.toString('base64');
+            return {
+                success: true,
+                output: base64,
+                noteCount: notes.length,
+                bars: options.bars || 4,
+                bpm: options.bpm || 120
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: '',
+                noteCount: 0,
+                bars: options.bars || 4,
+                bpm: options.bpm || 120,
+                error: `MIDI export failed: ${error.message}`
+            };
+        }
+    }
+}

package/dist/services/MusicTheory.js

@@ -0,0 +1,186 @@
+export class MusicTheory {
+    scales = {
+        major: [0, 2, 4, 5, 7, 9, 11],
+        minor: [0, 2, 3, 5, 7, 8, 10],
+        dorian: [0, 2, 3, 5, 7, 9, 10],
+        phrygian: [0, 1, 3, 5, 7, 8, 10],
+        lydian: [0, 2, 4, 6, 7, 9, 11],
+        mixolydian: [0, 2, 4, 5, 7, 9, 10],
+        aeolian: [0, 2, 3, 5, 7, 8, 10],
+        locrian: [0, 1, 3, 5, 6, 8, 10],
+        pentatonic: [0, 2, 4, 7, 9],
+        blues: [0, 3, 5, 6, 7, 10],
+        chromatic: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+        wholetone: [0, 2, 4, 6, 8, 10],
+        harmonic_minor: [0, 2, 3, 5, 7, 8, 11],
+        melodic_minor: [0, 2, 3, 5, 7, 9, 11]
+    };
+    chordProgressions = {
+        pop: ['I', 'V', 'vi', 'IV'],
+        jazz: ['IIM7', 'V7', 'IM7'],
+        blues: ['I7', 'I7', 'I7', 'I7', 'IV7', 'IV7', 'I7', 'I7', 'V7', 'IV7', 'I7', 'V7'],
+        folk: ['I', 'IV', 'I', 'V'],
+        rock: ['I', 'bVII', 'IV', 'I'],
+        classical: ['I', 'IV', 'V', 'I'],
+        modal: ['i', 'bVII', 'IV', 'i'],
+        edm: ['i', 'VI', 'III', 'VII']
+    };
+    /**
+     * Generates a musical scale from a root note
+     * @param root - Root note (e.g., 'C', 'D#', 'F')
+     * @param scaleName - Scale type (e.g., 'major', 'minor', 'pentatonic')
+     * @returns Array of note names in the scale
+     * @throws {Error} When root note or scale name is invalid
+     */
+    generateScale(root, scaleName) {
+        const noteNames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+        const rootIndex = noteNames.indexOf(root.toUpperCase());
+        if (rootIndex === -1) {
+            throw new Error(`Invalid root note: ${root}`);
+        }
+        const scale = this.scales[scaleName];
+        if (!scale) {
+            throw new Error(`Invalid scale: ${scaleName}`);
+        }
+        return scale.map(interval => {
+            const noteIndex = (rootIndex + interval) % 12;
+            return noteNames[noteIndex];
+        });
+    }
+    /**
+     * Generates a chord progression for a given key and style
+     * @param key - Musical key (e.g., 'C', 'Am')
+     * @param style - Progression style (e.g., 'pop', 'jazz', 'blues')
+     * @returns Space-separated string of chord names
+     * @throws {Error} When style is invalid
+     */
+    generateChordProgression(key, style) {
+        const progression = this.chordProgressions[style];
+        if (!progression) {
+            throw new Error(`Invalid progression style: ${style}`);
+        }
+        const chordMap = {
+            'I': key,
+            'I7': `${key}7`,
+            'i': `${key.toLowerCase()}m`,
+            'ii': `${this.getNote(key, 2)}m`,
+            'IIM7': `${this.getNote(key, 2)}m7`,
+            'iii': `${this.getNote(key, 4)}m`,
+            'III': this.getNote(key, 4),
+            'IV': this.getNote(key, 5),
+            'IV7': `${this.getNote(key, 5)}7`,
+            'V': this.getNote(key, 7),
+            'V7': `${this.getNote(key, 7)}7`,
+            'vi': `${this.getNote(key, 9)}m`,
+            'VI': this.getNote(key, 9),
+            'VII': this.getNote(key, 11),
+            'bVII': this.getNote(key, 10),
+            'IM7': `${key}maj7`
+        };
+        return progression
+            .map(chord => chordMap[chord] || key)
+            .join(' ');
+    }
+    /**
+     * Calculates a note at a given interval from the root
+     * @param root - Root note name
+     * @param semitones - Number of semitones to transpose
+     * @returns Transposed note name
+     */
+    getNote(root, semitones) {
+        const noteNames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+        const rootIndex = noteNames.indexOf(root.toUpperCase());
+        if (rootIndex === -1)
+            return root;
+        return noteNames[(rootIndex + semitones) % 12];
+    }
+    /**
+     * Generates a Euclidean rhythm pattern
+     * @param hits - Number of hits/beats in the pattern
+     * @param steps - Total number of steps in the pattern
+     * @returns Space-separated string of '1' (hit) and '~' (rest)
+     * @throws {Error} When hits exceed steps
+     */
+    generateEuclideanRhythm(hits, steps) {
+        if (hits > steps) {
+            throw new Error('Hits cannot exceed steps');
+        }
+        const pattern = new Array(steps).fill(false);
+        const interval = steps / hits;
+        for (let i = 0; i < hits; i++) {
+            const index = Math.floor(i * interval);
+            pattern[index] = true;
+        }
+        return pattern.map(hit => hit ? '1' : '~').join(' ');
+    }
+    /**
+     * Generates a polyrhythm from two Euclidean patterns
+     * @param pattern1 - Number of hits for first rhythm
+     * @param pattern2 - Number of hits for second rhythm
+     * @param length - Total length of patterns (default: 16)
+     * @returns Formatted polyrhythm string
+     */
+    generatePolyrhythm(pattern1, pattern2, length = 16) {
+        const rhythm1 = this.generateEuclideanRhythm(pattern1, length);
+        const rhythm2 = this.generateEuclideanRhythm(pattern2, length);
+        return `[${rhythm1}], [${rhythm2}]`;
+    }
+    /**
+     * Gets scale notes with octave numbers
+     * @param root - Root note of the scale
+     * @param scaleName - Type of scale to generate
+     * @param octave - Octave number (default: 3)
+     * @returns Array of notes with octave numbers (e.g., ['c3', 'd3', 'e3'])
+     */
+    getScaleNotes(root, scaleName, octave = 3) {
+        const scale = this.generateScale(root, scaleName);
+        return scale.map(note => `${note.toLowerCase()}${octave}`);
+    }
+    /**
+     * Generates an arpeggio pattern from a chord
+     * @param chord - Chord name to arpeggiate
+     * @param pattern - Arpeggio pattern ('up', 'down', 'updown', 'random')
+     * @returns Space-separated string of notes in arpeggio order
+     */
+    generateArpeggio(chord, pattern = 'up') {
+        const patterns = {
+            'up': [0, 1, 2, 3],
+            'down': [3, 2, 1, 0],
+            'updown': [0, 1, 2, 3, 2, 1],
+            'random': [0, 2, 1, 3, 0, 3, 1, 2]
+        };
+        const arpPattern = patterns[pattern] || patterns['up'];
+        const notes = this.getChordNotes(chord);
+        return arpPattern
+            .map(index => notes[index % notes.length])
+            .join(' ');
+    }
+    /**
+     * Extracts individual notes from a chord name
+     * Parses chord symbols and returns note names with octave numbers
+     * @param chord - Chord name to parse (e.g., 'Cmaj7', 'Am', 'G7')
+     * @returns Array of note names with octave numbers (e.g., ['c3', 'e3', 'g3'])
+     * @example
+     * const notes = this.getChordNotes('Cmaj7');
+     * // Returns: ['c3', 'e3', 'g3', 'b3']
+     */
+    getChordNotes(chord) {
+        // Simplified chord parsing - would need more sophisticated implementation
+        const root = chord.replace(/[^A-G#]/g, '');
+        const type = chord.replace(/[A-G#]/g, '');
+        const intervals = {
+            '': [0, 4, 7], // major
+            'm': [0, 3, 7], // minor
+            '7': [0, 4, 7, 10], // dominant 7
+            'maj7': [0, 4, 7, 11], // major 7
+            'm7': [0, 3, 7, 10], // minor 7
+            'dim': [0, 3, 6], // diminished
+            'aug': [0, 4, 8] // augmented
+        };
+        const chordIntervals = intervals[type] || intervals[''];
+        return chordIntervals.map(interval => {
+            const note = this.getNote(root, interval);
+            return `${note.toLowerCase()}3`;
+        });
+    }
+}