@williamzujkowski/live-coding-music-mcp 1.0.0

package/dist/server/tools/capture.js

@@ -0,0 +1,184 @@
+/**
+ * capture domain — audio recording and MIDI export.
+ *
+ * Owns (4 tools): start_audio_capture, stop_audio_capture,
+ * capture_audio_sample, export_midi.
+ *
+ * Per the #110 audit, the three audio_capture tools collapse into a
+ * single `audio_capture(action=start|stop|sample)` post-split.
+ * `export_midi` stays separate — MIDI is symbolic, audio is waveform.
+ *
+ * The AudioCaptureService is lazy-instantiated module-side: we need
+ * the current Playwright page for `injectRecorder()`, and that only
+ * exists after `init`. The singleton survives across tool calls.
+ */
+import { InputValidator } from '../../utils/InputValidator.js';
+// AudioCaptureService lifecycle lives on the server; we fetch a shared
+// instance via ctx.getAudioCaptureService() so tests can mock the class
+// at module boundary without the extractor caching a stale instance.
+function blobToBase64(arrayBuffer) {
+    const bytes = new Uint8Array(arrayBuffer);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+export const tools = [
+    {
+        name: 'start_audio_capture',
+        description: 'Start capturing audio from Strudel output. Audio must be playing for capture to work.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                format: { type: 'string', enum: ['webm', 'opus'], description: 'Audio format (default: webm)' },
+                maxDuration: { type: 'number', description: 'Maximum capture duration in milliseconds' },
+            },
+        },
+    },
+    {
+        name: 'stop_audio_capture',
+        description: 'Stop audio capture and return the recorded audio as base64-encoded data.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'capture_audio_sample',
+        description: 'Capture a fixed-duration audio sample from Strudel output. Audio must be playing.',
+        inputSchema: {
+            type: 'object',
+            properties: { duration: { type: 'number', description: 'Duration in milliseconds (default: 5000)' } },
+        },
+    },
+    {
+        name: 'export_midi',
+        description: 'Export current pattern to MIDI file. Parses note(), n(), and chord() functions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filename: { type: 'string', description: 'Output filename (optional, default: pattern.mid)' },
+                duration: { type: 'number', description: 'Export duration in bars (default: 4)' },
+                bpm: { type: 'number', description: 'Tempo in BPM (default: 120)' },
+                format: { type: 'string', enum: ['file', 'base64'], description: 'Output format: file or base64 (default: base64)' },
+            },
+        },
+    },
+];
+export const toolNames = new Set(tools.map(t => t.name));
+export async function execute(name, args, ctx) {
+    switch (name) {
+        case 'start_audio_capture':
+            return await startAudioCapture(args?.format, args?.maxDuration, ctx);
+        case 'stop_audio_capture':
+            return await stopAudioCapture(ctx);
+        case 'capture_audio_sample':
+            return await captureAudioSample(args?.duration, ctx);
+        case 'export_midi':
+            return await exportMidi(args?.filename, args?.duration, args?.bpm, args?.format, ctx);
+        default:
+            throw new Error(`capture module does not handle tool: ${name}`);
+    }
+}
+async function startAudioCapture(format, _maxDuration, ctx) {
+    try {
+        const service = await ctx.getAudioCaptureService();
+        if (service.isCapturing()) {
+            return { success: false, message: 'Audio capture already in progress. Stop it first.' };
+        }
+        await service.startCapture(ctx.controller.page, { format });
+        return {
+            success: true,
+            message: 'Audio capture started. Use stop_audio_capture to get the recorded audio.',
+            format: format || 'webm',
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, message: `Failed to start audio capture: ${message}` };
+    }
+}
+async function stopAudioCapture(ctx) {
+    try {
+        const service = await ctx.getAudioCaptureService();
+        if (!service.isCapturing()) {
+            return { success: false, message: 'No audio capture in progress. Start capture first.' };
+        }
+        const result = await service.stopCapture(ctx.controller.page);
+        const buf = await result.blob.arrayBuffer();
+        return {
+            success: true,
+            message: `Captured ${result.duration}ms of audio`,
+            audio: blobToBase64(buf),
+            duration: result.duration,
+            format: result.format,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, message: `Failed to stop audio capture: ${message}` };
+    }
+}
+async function captureAudioSample(duration, ctx) {
+    const durationMs = duration || 5000;
+    if (durationMs < 100 || durationMs > 60000) {
+        return { success: false, message: 'Duration must be between 100ms and 60000ms (1 minute)' };
+    }
+    try {
+        const service = await ctx.getAudioCaptureService();
+        if (service.isCapturing()) {
+            return { success: false, message: 'Audio capture already in progress. Stop it first.' };
+        }
+        const result = await service.captureForDuration(ctx.controller.page, durationMs);
+        const buf = await result.blob.arrayBuffer();
+        return {
+            success: true,
+            message: `Captured ${result.duration}ms audio sample`,
+            audio: blobToBase64(buf),
+            duration: result.duration,
+            format: result.format,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, message: `Failed to capture audio sample: ${message}` };
+    }
+}
+async function exportMidi(filename, bars, bpm, format, ctx) {
+    if (bpm !== undefined)
+        InputValidator.validateBPM(bpm);
+    if (bars !== undefined && (bars < 1 || bars > 128)) {
+        return { success: false, message: 'Bars must be between 1 and 128' };
+    }
+    const pattern = await ctx.getCurrentPatternSafe();
+    if (!pattern || pattern.trim().length === 0) {
+        return { success: false, message: 'No pattern to export. Write a pattern first.' };
+    }
+    const exportOptions = { bpm: bpm || 120, bars: bars || 4 };
+    const outputFormat = format || 'base64';
+    if (outputFormat === 'file') {
+        const result = ctx.midiExportService.exportToFile(pattern, filename, exportOptions);
+        return {
+            success: result.success,
+            message: result.success
+                ? `Exported ${result.noteCount} notes to ${result.output}`
+                : result.error || 'Export failed',
+            output: result.output,
+            noteCount: result.noteCount,
+            bars: result.bars,
+            bpm: result.bpm,
+            error: result.error,
+        };
+    }
+    const result = ctx.midiExportService.exportToBase64(pattern, exportOptions);
+    return {
+        success: result.success,
+        message: result.success
+            ? `Exported ${result.noteCount} notes as base64 MIDI data`
+            : result.error || 'Export failed',
+        output: result.output,
+        noteCount: result.noteCount,
+        bars: result.bars,
+        bpm: result.bpm,
+        error: result.error,
+    };
+}
+export const captureModule = { tools, toolNames, execute };

package/dist/server/tools/diagnostics.js

@@ -0,0 +1,96 @@
+/**
+ * diagnostics domain — performance, memory, status, errors, screenshots.
+ *
+ * Owns (6 tools today): performance_report, memory_usage, screenshot,
+ * status, diagnostics, show_errors.
+ *
+ * Post-consolidation target (per #110 audit): one `diagnostics` tool with
+ * a `level` enum. For now we keep the individual verbs and only move them
+ * out of server.ts; consolidation happens later under #120.
+ */
+export const tools = [
+    {
+        name: 'performance_report',
+        description: 'Get performance metrics and bottlenecks',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'memory_usage',
+        description: 'Get current memory usage statistics',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'screenshot',
+        description: 'Take a screenshot of the current Strudel editor state',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filename: { type: 'string', description: 'Optional filename for screenshot' },
+            },
+        },
+    },
+    {
+        name: 'status',
+        description: 'Get current browser and playback status (quick state check)',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'diagnostics',
+        description: 'Get detailed browser diagnostics including cache, errors, and performance',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'show_errors',
+        description: 'Display captured console errors and warnings from Strudel',
+        inputSchema: { type: 'object', properties: {} },
+    },
+];
+export const toolNames = new Set(tools.map(t => t.name));
+export async function execute(name, args, ctx) {
+    switch (name) {
+        case 'performance_report': {
+            const report = ctx.perfMonitor.getReport();
+            const bottlenecks = ctx.perfMonitor.getBottlenecks(5);
+            return `${report}\n\nTop 5 Bottlenecks:\n${JSON.stringify(bottlenecks, null, 2)}`;
+        }
+        case 'memory_usage': {
+            const memory = ctx.perfMonitor.getMemoryUsage();
+            return memory ? JSON.stringify(memory, null, 2) : 'Memory usage not available';
+        }
+        case 'screenshot': {
+            if (!ctx.isInitialized()) {
+                return 'Browser not initialized. Run init first.';
+            }
+            return await ctx.controller.takeScreenshot(args?.filename);
+        }
+        case 'status':
+            return ctx.controller.getStatus();
+        case 'diagnostics': {
+            if (!ctx.isInitialized()) {
+                return {
+                    initialized: false,
+                    message: 'Browser not initialized. Run init first for full diagnostics.',
+                };
+            }
+            return await ctx.controller.getDiagnostics();
+        }
+        case 'show_errors': {
+            const errors = ctx.controller.getConsoleErrors();
+            const warnings = ctx.controller.getConsoleWarnings();
+            if (errors.length === 0 && warnings.length === 0) {
+                return 'No errors or warnings captured.';
+            }
+            let result = '';
+            if (errors.length > 0) {
+                result += `❌ Errors (${errors.length}):\n${errors.map(e => `  • ${e}`).join('\n')}\n`;
+            }
+            if (warnings.length > 0) {
+                result += `⚠️ Warnings (${warnings.length}):\n${warnings.map(w => `  • ${w}`).join('\n')}`;
+            }
+            return result.trim();
+        }
+        default:
+            throw new Error(`diagnostics module does not handle tool: ${name}`);
+    }
+}
+export const diagnosticsModule = { tools, toolNames, execute };

package/dist/server/tools/editor.js

@@ -0,0 +1,128 @@
+/**
+ * editor domain — pattern editing in the CodeMirror editor.
+ *
+ * Owns (6 tools): write, append, insert, replace, clear, get_pattern.
+ * Post-consolidation per the #110 audit: the five mutating tools
+ * collapse into an `edit_pattern` tool with a `mode` enum, while
+ * `get_pattern` stays separate (hot read path).
+ */
+import { InputValidator } from '../../utils/InputValidator.js';
+export const tools = [
+    {
+        name: 'write',
+        description: 'Write pattern to editor with optional auto-play and validation',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Pattern code' },
+                auto_play: { type: 'boolean', description: 'Start playback immediately after writing (default: false)' },
+                validate: { type: 'boolean', description: 'Validate pattern before writing (default: true)' },
+            },
+            required: ['pattern'],
+        },
+    },
+    {
+        name: 'append',
+        description: 'Append code to current pattern',
+        inputSchema: {
+            type: 'object',
+            properties: { code: { type: 'string', description: 'Code to append' } },
+            required: ['code'],
+        },
+    },
+    {
+        name: 'insert',
+        description: 'Insert code at specific line',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                position: { type: 'number', description: 'Line number' },
+                code: { type: 'string', description: 'Code to insert' },
+            },
+            required: ['position', 'code'],
+        },
+    },
+    {
+        name: 'replace',
+        description: 'Replace pattern section',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                search: { type: 'string', description: 'Text to replace' },
+                replace: { type: 'string', description: 'Replacement text' },
+            },
+            required: ['search', 'replace'],
+        },
+    },
+    {
+        name: 'clear',
+        description: 'Clear the editor',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'get_pattern',
+        description: 'Get current pattern code',
+        inputSchema: { type: 'object', properties: {} },
+    },
+];
+export const toolNames = new Set(tools.map(t => t.name));
+export async function execute(name, args, ctx) {
+    switch (name) {
+        case 'write': {
+            InputValidator.validateStringLength(args.pattern, 'pattern', 10000, true);
+            // Validate pattern if requested (default: true) — issue #40
+            if (args.validate !== false && ctx.isInitialized() && typeof ctx.controller.validatePattern === 'function') {
+                try {
+                    const validation = await ctx.controller.validatePattern(args.pattern);
+                    if (validation && !validation.valid) {
+                        return {
+                            success: false,
+                            errors: validation.errors,
+                            warnings: validation.warnings,
+                            suggestions: validation.suggestions,
+                            message: `Pattern validation failed: ${validation.errors.join('; ')}`,
+                        };
+                    }
+                }
+                catch {
+                    ctx.logger.warn('Pattern validation threw error, continuing with write');
+                }
+            }
+            const writeResult = await ctx.writePatternSafe(args.pattern);
+            // Auto-play if requested — issue #38
+            if (args.auto_play && ctx.isInitialized()) {
+                await ctx.controller.play();
+                return `${writeResult}. Playing.`;
+            }
+            return writeResult;
+        }
+        case 'append': {
+            InputValidator.validateStringLength(args.code, 'code', 10000, true);
+            const current = await ctx.getCurrentPatternSafe();
+            return await ctx.writePatternSafe(current + '\n' + args.code);
+        }
+        case 'insert': {
+            InputValidator.validatePositiveInteger(args.position, 'position');
+            InputValidator.validateStringLength(args.code, 'code', 10000, true);
+            const lines = (await ctx.getCurrentPatternSafe()).split('\n');
+            lines.splice(args.position, 0, args.code);
+            return await ctx.writePatternSafe(lines.join('\n'));
+        }
+        case 'replace': {
+            InputValidator.validateStringLength(args.search, 'search', 1000, true);
+            InputValidator.validateStringLength(args.replace, 'replace', 10000, true);
+            const pattern = await ctx.getCurrentPatternSafe();
+            // Escape $ in replacement to prevent special sequence injection ($&, $1, $', etc.)
+            const safeReplacement = args.replace.replace(/\$/g, '$$$$');
+            const replaced = pattern.replace(args.search, safeReplacement);
+            return await ctx.writePatternSafe(replaced);
+        }
+        case 'clear':
+            return await ctx.writePatternSafe('');
+        case 'get_pattern':
+            return await ctx.getCurrentPatternSafe();
+        default:
+            throw new Error(`editor module does not handle tool: ${name}`);
+    }
+}
+export const editorModule = { tools, toolNames, execute };

package/dist/server/tools/generate.js

@@ -0,0 +1,218 @@
+/**
+ * generate domain — pattern and music-theory generation (no browser needed).
+ *
+ * Owns (9 tools):
+ *   generate_pattern, generate_drums, generate_bassline, generate_melody,
+ *   generate_fill, generate_scale, generate_chord_progression,
+ *   generate_euclidean, generate_polyrhythm
+ *
+ * `compose` stays in server.ts for now — it orchestrates init + generate
+ * + play + optional AI feedback and pairs with ai.ts when that extraction
+ * happens. Per the #110 audit, compose eventually absorbs generate_pattern
+ * and the four generate_* drums/bass/melody/fill tools collapse into
+ * `generate_part(role)`, while scale+chord_prog become `music_theory`.
+ */
+import { InputValidator } from '../../utils/InputValidator.js';
+export const tools = [
+    {
+        name: 'generate_pattern',
+        description: 'Generate complete pattern from style with optional auto-play',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                style: { type: 'string', description: 'Music style (techno/house/dnb/ambient/etc)' },
+                key: { type: 'string', description: 'Musical key' },
+                bpm: { type: 'number', description: 'Tempo in BPM' },
+                auto_play: { type: 'boolean', description: 'Start playback immediately (default: false)' },
+            },
+            required: ['style'],
+        },
+    },
+    {
+        name: 'generate_drums',
+        description: 'Generate drum pattern',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                style: { type: 'string', description: 'Drum style' },
+                complexity: { type: 'number', description: 'Complexity (0-1)' },
+            },
+            required: ['style'],
+        },
+    },
+    {
+        name: 'generate_bassline',
+        description: 'Generate bassline',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Musical key' },
+                style: { type: 'string', description: 'Bass style' },
+            },
+            required: ['key', 'style'],
+        },
+    },
+    {
+        name: 'generate_melody',
+        description: 'Generate melody from scale',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                scale: { type: 'string', description: 'Scale name' },
+                root: { type: 'string', description: 'Root note' },
+                length: { type: 'number', description: 'Number of notes' },
+            },
+            required: ['scale', 'root'],
+        },
+    },
+    {
+        name: 'generate_scale',
+        description: 'Generate scale notes',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                root: { type: 'string', description: 'Root note' },
+                scale: { type: 'string', description: 'Scale type' },
+            },
+            required: ['root', 'scale'],
+        },
+    },
+    {
+        name: 'generate_chord_progression',
+        description: 'Generate chord progression',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Key' },
+                style: { type: 'string', description: 'Style (pop/jazz/blues/etc)' },
+            },
+            required: ['key', 'style'],
+        },
+    },
+    {
+        name: 'generate_euclidean',
+        description: 'Generate Euclidean rhythm',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                hits: { type: 'number', description: 'Number of hits' },
+                steps: { type: 'number', description: 'Total steps' },
+                sound: { type: 'string', description: 'Sound to use' },
+            },
+            required: ['hits', 'steps'],
+        },
+    },
+    {
+        name: 'generate_polyrhythm',
+        description: 'Generate polyrhythm',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sounds: { type: 'array', items: { type: 'string' }, description: 'Sounds to use' },
+                patterns: { type: 'array', items: { type: 'number' }, description: 'Pattern numbers' },
+            },
+            required: ['sounds', 'patterns'],
+        },
+    },
+    {
+        name: 'generate_fill',
+        description: 'Generate drum fill',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                style: { type: 'string', description: 'Fill style' },
+                bars: { type: 'number', description: 'Number of bars' },
+            },
+            required: ['style'],
+        },
+    },
+];
+export const toolNames = new Set(tools.map(t => t.name));
+async function appendOrSet(generated, ctx) {
+    const current = await ctx.getCurrentPatternSafe();
+    const combined = current ? current + '\n' + generated : generated;
+    await ctx.writePatternSafe(combined);
+}
+export async function execute(name, args, ctx) {
+    switch (name) {
+        case 'generate_pattern': {
+            InputValidator.validateStringLength(args.style, 'style', 100, false);
+            if (args.key)
+                InputValidator.validateRootNote(args.key);
+            if (args.bpm !== undefined)
+                InputValidator.validateBPM(args.bpm);
+            const generated = ctx.generator.generateCompletePattern(args.style, args.key || 'C', args.bpm || 120);
+            await ctx.writePatternSafe(generated);
+            if (args.auto_play && ctx.isInitialized()) {
+                await ctx.controller.play();
+                return `Generated ${args.style} pattern. Playing.`;
+            }
+            return `Generated ${args.style} pattern`;
+        }
+        case 'generate_drums': {
+            InputValidator.validateStringLength(args.style, 'style', 100, false);
+            if (args.complexity !== undefined)
+                InputValidator.validateNormalizedValue(args.complexity, 'complexity');
+            const drums = ctx.generator.generateDrumPattern(args.style, args.complexity || 0.5);
+            await appendOrSet(drums, ctx);
+            return `Generated ${args.style} drums`;
+        }
+        case 'generate_bassline': {
+            InputValidator.validateRootNote(args.key);
+            InputValidator.validateStringLength(args.style, 'style', 100, false);
+            const bass = ctx.generator.generateBassline(args.key, args.style);
+            await appendOrSet(bass, ctx);
+            return `Generated ${args.style} bassline in ${args.key}`;
+        }
+        case 'generate_melody': {
+            InputValidator.validateRootNote(args.root);
+            InputValidator.validateScaleName(args.scale);
+            if (args.length !== undefined)
+                InputValidator.validatePositiveInteger(args.length, 'length');
+            const scale = ctx.theory.generateScale(args.root, args.scale);
+            const melody = ctx.generator.generateMelody(scale, args.length || 8);
+            await appendOrSet(melody, ctx);
+            return `Generated melody in ${args.root} ${args.scale}`;
+        }
+        case 'generate_scale': {
+            InputValidator.validateRootNote(args.root);
+            InputValidator.validateScaleName(args.scale);
+            const notes = ctx.theory.generateScale(args.root, args.scale);
+            return `${args.root} ${args.scale} scale: ${notes.join(', ')}`;
+        }
+        case 'generate_chord_progression': {
+            InputValidator.validateRootNote(args.key);
+            InputValidator.validateChordStyle(args.style);
+            const progression = ctx.theory.generateChordProgression(args.key, args.style);
+            const chordPattern = ctx.generator.generateChords(progression);
+            await appendOrSet(chordPattern, ctx);
+            return `Generated ${args.style} progression in ${args.key}: ${progression}`;
+        }
+        case 'generate_euclidean': {
+            InputValidator.validateEuclidean(args.hits, args.steps);
+            if (args.sound)
+                InputValidator.validateStringLength(args.sound, 'sound', 100, false);
+            const euclidean = ctx.generator.generateEuclideanPattern(args.hits, args.steps, args.sound || 'bd');
+            await appendOrSet(euclidean, ctx);
+            return `Generated Euclidean rhythm (${args.hits}/${args.steps})`;
+        }
+        case 'generate_polyrhythm': {
+            args.sounds.forEach((s) => InputValidator.validateStringLength(s, 'sound', 100, false));
+            args.patterns.forEach((p) => InputValidator.validatePositiveInteger(p, 'pattern'));
+            const poly = ctx.generator.generatePolyrhythm(args.sounds, args.patterns);
+            await appendOrSet(poly, ctx);
+            return 'Generated polyrhythm';
+        }
+        case 'generate_fill': {
+            InputValidator.validateStringLength(args.style, 'style', 100, false);
+            if (args.bars !== undefined)
+                InputValidator.validatePositiveInteger(args.bars, 'bars');
+            const fill = ctx.generator.generateFill(args.style, args.bars || 1);
+            await appendOrSet(fill, ctx);
+            return `Generated ${args.bars || 1} bar fill`;
+        }
+        default:
+            throw new Error(`generate module does not handle tool: ${name}`);
+    }
+}
+export const generateModule = { tools, toolNames, execute };