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

package/dist/server/tools/capture.js

@@ -1,12 +1,8 @@
 /**
  * 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.
+ * Owns two tools: `audio_capture(action=start|stop|sample)` and
+ * `export_midi` (kept 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
@@ -24,29 +20,33 @@ function blobToBase64(arrayBuffer) {
     }
     return btoa(binary);
 }
+const SESSION_ID_PROP = {
+    session_id: {
+        type: 'string',
+        description: 'Optional session ID (#108). Routes page reference to the named session. Note: AudioCaptureService is currently server-wide — concurrent captures across sessions will conflict.',
+    },
+};
 export const tools = [
     {
-        name: 'start_audio_capture',
-        description: 'Start capturing audio from Strudel output. Audio must be playing for capture to work.',
+        name: 'audio_capture',
+        description: 'Record audio output from the live Strudel session. ' +
+            'action=start begins streaming capture (optional `format` webm/opus, default webm). ' +
+            'action=stop ends the stream and returns base64-encoded audio. ' +
+            'action=sample captures a fixed-`duration` window in one call (100-60000ms, default 5000ms). ' +
+            'Example: audio_capture({ action: "sample", duration: 3000 }). ' +
+            'Audio must be playing for capture to record meaningful data. ' +
+            'For MIDI export use export_midi; for runtime diagnostics use diagnostics. ' +
+            'Note: the AudioCaptureService is currently a server-wide singleton — concurrent captures across sessions will conflict.',
         inputSchema: {
             type: 'object',
             properties: {
-                format: { type: 'string', enum: ['webm', 'opus'], description: 'Audio format (default: webm)' },
-                maxDuration: { type: 'number', description: 'Maximum capture duration in milliseconds' },
+                action: { type: 'string', enum: ['start', 'stop', 'sample'], description: 'Capture action' },
+                format: { type: 'string', enum: ['webm', 'opus'], description: 'action=start: audio format (default webm)' },
+                maxDuration: { type: 'number', description: 'action=start: maximum capture duration ms' },
+                duration: { type: 'number', description: 'action=sample: duration ms (100-60000, default 5000)' },
+                ...SESSION_ID_PROP,
             },
-        },
-    },
-    {
-        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)' } },
+            required: ['action'],
         },
     },
     {
@@ -59,35 +59,44 @@ export const tools = [
                 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)' },
+                ...SESSION_ID_PROP,
             },
         },
     },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
 export async function execute(name, args, ctx) {
+    const sid = args?.session_id;
+    // No outer init check: each capture handler has try/catch that
+    // produces a structured { success: false, message } from any error,
+    // including AudioCaptureService's "Browser not initialized" throw.
     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 'audio_capture': {
+            const a = args?.action;
+            switch (a) {
+                case 'start': return await startAudioCapture(args?.format, args?.maxDuration, ctx, sid);
+                case 'stop': return await stopAudioCapture(ctx, sid);
+                case 'sample': return await captureAudioSample(args?.duration, ctx, sid);
+                default:
+                    throw new Error(`Invalid action: ${a}. Must be one of: start, stop, sample`);
+            }
+        }
         case 'export_midi':
-            return await exportMidi(args?.filename, args?.duration, args?.bpm, args?.format, ctx);
+            return await exportMidi(args?.filename, args?.duration, args?.bpm, args?.format, ctx, sid);
         default:
             throw new Error(`capture module does not handle tool: ${name}`);
     }
 }
-async function startAudioCapture(format, _maxDuration, ctx) {
+async function startAudioCapture(format, _maxDuration, ctx, sid) {
     try {
-        const service = await ctx.getAudioCaptureService();
+        const service = await ctx.getAudioCaptureService(sid);
         if (service.isCapturing()) {
             return { success: false, message: 'Audio capture already in progress. Stop it first.' };
         }
-        await service.startCapture(ctx.controller.page, { format });
+        await service.startCapture(ctx.getController(sid).page, { format });
         return {
             success: true,
-            message: 'Audio capture started. Use stop_audio_capture to get the recorded audio.',
+            message: 'Audio capture started. Use audio_capture({ action: "stop" }) to get the recorded audio.',
             format: format || 'webm',
         };
     }
@@ -96,13 +105,13 @@ async function startAudioCapture(format, _maxDuration, ctx) {
         return { success: false, message: `Failed to start audio capture: ${message}` };
     }
 }
-async function stopAudioCapture(ctx) {
+async function stopAudioCapture(ctx, sid) {
     try {
-        const service = await ctx.getAudioCaptureService();
+        const service = await ctx.getAudioCaptureService(sid);
         if (!service.isCapturing()) {
             return { success: false, message: 'No audio capture in progress. Start capture first.' };
         }
-        const result = await service.stopCapture(ctx.controller.page);
+        const result = await service.stopCapture(ctx.getController(sid).page);
         const buf = await result.blob.arrayBuffer();
         return {
             success: true,
@@ -117,17 +126,17 @@ async function stopAudioCapture(ctx) {
         return { success: false, message: `Failed to stop audio capture: ${message}` };
     }
 }
-async function captureAudioSample(duration, ctx) {
+async function captureAudioSample(duration, ctx, sid) {
     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();
+        const service = await ctx.getAudioCaptureService(sid);
         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 result = await service.captureForDuration(ctx.getController(sid).page, durationMs);
         const buf = await result.blob.arrayBuffer();
         return {
             success: true,
@@ -142,13 +151,13 @@ async function captureAudioSample(duration, ctx) {
         return { success: false, message: `Failed to capture audio sample: ${message}` };
     }
 }
-async function exportMidi(filename, bars, bpm, format, ctx) {
+async function exportMidi(filename, bars, bpm, format, ctx, sid) {
     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();
+    const pattern = await ctx.getCurrentPatternSafe(sid);
     if (!pattern || pattern.trim().length === 0) {
         return { success: false, message: 'No pattern to export. Write a pattern first.' };
     }

package/dist/server/tools/compose.js

@@ -0,0 +1,145 @@
+/**
+ * compose domain — high-level UX tools that aren't a thin verb on a
+ * subsystem: `compose` (one-shot generate+write+play) and
+ * `browser_window` (show or screenshot the Strudel window).
+ */
+import { InputValidator } from '../../utils/InputValidator.js';
+const SESSION_ID_PROP = {
+    session_id: {
+        type: 'string',
+        description: 'Optional session ID (#108). Omit to use default session. compose auto-init only applies to default session — named sessions must already exist.',
+    },
+};
+export const tools = [
+    {
+        name: 'browser_window',
+        description: 'Interact with the visible Strudel browser window. ' +
+            'action=show brings the window to the foreground. ' +
+            'action=screenshot captures the current editor view to disk (optional `filename`). ' +
+            'Example: browser_window({ action: "screenshot", filename: "demo.png" }). ' +
+            'For diagnostics (status/errors/perf) use diagnostics; for the editor itself use edit_pattern.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', enum: ['show', 'screenshot'], description: 'Window action' },
+                filename: { type: 'string', description: 'action=screenshot: optional output filename' },
+                ...SESSION_ID_PROP,
+            },
+            required: ['action'],
+        },
+    },
+    {
+        name: 'compose',
+        description: 'Generate, write, and play a complete pattern in one step. Auto-initializes default browser if needed.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                style: { type: 'string', description: 'Genre: techno, house, dnb, ambient, trap, jungle, jazz, experimental' },
+                tempo: { type: 'number', description: 'BPM (default: genre-appropriate)' },
+                key: { type: 'string', description: 'Musical key (default: C)' },
+                auto_play: { type: 'boolean', description: 'Start playback immediately (default: true)' },
+                get_feedback: { type: 'boolean', description: 'Get AI feedback on the generated pattern (default: false)' },
+                ...SESSION_ID_PROP,
+            },
+            required: ['style'],
+        },
+    },
+];
+export const toolNames = new Set(tools.map(t => t.name));
+const TEMPO_BY_STYLE = {
+    techno: 130,
+    house: 125,
+    dnb: 174,
+    'drum and bass': 174,
+    ambient: 80,
+    trap: 140,
+    jungle: 160,
+    jazz: 110,
+    experimental: 120,
+    dubstep: 140,
+    trance: 138,
+    breakbeat: 130,
+    garage: 130,
+    electro: 128,
+    downtempo: 90,
+    idm: 115,
+};
+function defaultTempo(style) {
+    return TEMPO_BY_STYLE[style.toLowerCase()] ?? 120;
+}
+async function doShow(ctx, sid) {
+    if (!sid && !ctx.isInitialized()) {
+        return 'Browser not initialized. Run init first.';
+    }
+    return await ctx.getController(sid).showBrowser();
+}
+async function doScreenshot(args, ctx, sid) {
+    if (!sid && !ctx.isInitialized()) {
+        return 'Browser not initialized. Run init first.';
+    }
+    return await ctx.getController(sid).takeScreenshot(args?.filename);
+}
+export async function execute(name, args, ctx) {
+    const sid = args?.session_id;
+    switch (name) {
+        case 'browser_window': {
+            const a = args?.action;
+            if (a !== 'show' && a !== 'screenshot') {
+                throw new Error(`Invalid action: ${a}. Must be one of: show, screenshot`);
+            }
+            return a === 'show' ? await doShow(ctx, sid) : await doScreenshot(args, ctx, sid);
+        }
+        case 'compose': {
+            InputValidator.validateStringLength(args.style, 'style', 100, false);
+            if (args.key) {
+                InputValidator.validateRootNote(args.key);
+            }
+            if (args.tempo !== undefined) {
+                InputValidator.validateBPM(args.tempo);
+            }
+            // Auto-init only the default session. Named sessions must be
+            // created via `create_session` first — ctx.getController(sid)
+            // throws if missing, which the dispatcher renders as err('business').
+            if (!sid) {
+                await ctx.ensureInitialized();
+            }
+            const controller = ctx.getController(sid);
+            const tempo = args.tempo || defaultTempo(args.style);
+            const key = args.key || 'C';
+            const pattern = ctx.generator.generateCompletePattern(args.style, key, tempo);
+            await controller.writePattern(pattern);
+            const shouldPlay = args.auto_play !== false;
+            if (shouldPlay) {
+                await controller.play();
+            }
+            const response = {
+                success: true,
+                pattern: pattern.substring(0, 200) + (pattern.length > 200 ? '...' : ''),
+                metadata: { style: args.style, bpm: tempo, key },
+                status: shouldPlay ? 'playing' : 'ready',
+                message: `Created ${args.style} pattern in ${key}${shouldPlay ? ' - now playing' : ''}`,
+            };
+            if (args.get_feedback) {
+                if (ctx.geminiService.isAvailable()) {
+                    try {
+                        const feedback = await ctx.geminiService.getCreativeFeedback(pattern);
+                        response.feedback = feedback;
+                        response.message += ` (AI feedback: ${feedback.complexity} complexity, estimated ${feedback.estimatedStyle})`;
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        ctx.logger.warn('Failed to get AI feedback for compose', { error: message });
+                        response.message += ' (AI feedback unavailable)';
+                    }
+                }
+                else {
+                    response.message += ' (AI feedback requires GEMINI_API_KEY)';
+                }
+            }
+            return response;
+        }
+        default:
+            throw new Error(`compose module does not handle tool: ${name}`);
+    }
+}
+export const composeModule = { tools, toolNames, execute };

package/dist/server/tools/diagnostics.js

@@ -1,93 +1,98 @@
 /**
- * diagnostics domain — performance, memory, status, errors, screenshots.
+ * diagnostics domain — observability tools (browser status, errors,
+ * server metrics).
  *
- * Owns (6 tools today): performance_report, memory_usage, screenshot,
- * status, diagnostics, show_errors.
+ * Owns one consolidated tool (`diagnostics(level)`) with status/full/
+ * perf/memory/errors levels.
  *
- * 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.
+ * The `<15ms` SLA on `level='status'` is preserved — that branch only
+ * reads from the controller's cache, not the browser. Other levels can
+ * touch the browser (`level='full'`) or just inspect server state
+ * (`perf`, `memory`).
  */
-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: {} },
+const SESSION_ID_PROP = {
+    session_id: {
+        type: 'string',
+        description: 'Optional session ID (#108). Applies to level=status, full, errors. Ignored for perf/memory (server-wide metrics).',
     },
+};
+export const tools = [
     {
-        name: 'screenshot',
-        description: 'Take a screenshot of the current Strudel editor state',
+        name: 'diagnostics',
+        description: 'Inspect server and browser state. ' +
+            'level=status returns a quick state snapshot (cache read, <15ms SLA). ' +
+            'level=full returns detailed browser diagnostics including caches, errors, and performance. ' +
+            'level=perf returns server-side timing metrics + top bottlenecks. ' +
+            'level=memory returns process memory usage. ' +
+            'level=errors returns captured console errors and warnings from Strudel. ' +
+            'Default level=full preserves the pre-consolidation behaviour. ' +
+            'Example: diagnostics({ level: "status" }) — millisecond-cheap. ' +
+            'For screenshots use browser_window; for tool listings use the strudel://docs/tools resource.',
         inputSchema: {
             type: 'object',
             properties: {
-                filename: { type: 'string', description: 'Optional filename for screenshot' },
+                level: {
+                    type: 'string',
+                    enum: ['status', 'full', 'perf', 'memory', 'errors'],
+                    description: 'Which diagnostic surface to read (default: full)',
+                },
+                ...SESSION_ID_PROP,
             },
         },
     },
-    {
-        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));
+function getPerformanceReport(ctx) {
+    const report = ctx.perfMonitor.getReport();
+    const bottlenecks = ctx.perfMonitor.getBottlenecks(5);
+    return `${report}\n\nTop 5 Bottlenecks:\n${JSON.stringify(bottlenecks, null, 2)}`;
+}
+function getMemoryUsage(ctx) {
+    const memory = ctx.perfMonitor.getMemoryUsage();
+    return memory ? JSON.stringify(memory, null, 2) : 'Memory usage not available';
+}
+function getStatus(ctx, sid) {
+    return ctx.getController(sid).getStatus();
+}
+async function getFullDiagnostics(ctx, sid) {
+    if (!sid && !ctx.isInitialized()) {
+        return {
+            initialized: false,
+            message: 'Browser not initialized. Run init first for full diagnostics.',
+        };
+    }
+    return await ctx.getController(sid).getDiagnostics();
+}
+function getErrors(ctx, sid) {
+    const controller = ctx.getController(sid);
+    const errors = controller.getConsoleErrors();
+    const warnings = 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();
+}
 export async function execute(name, args, ctx) {
+    const sid = args?.session_id;
     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')}`;
+            const level = args?.level ?? 'full';
+            switch (level) {
+                case 'status': return getStatus(ctx, sid);
+                case 'full': return await getFullDiagnostics(ctx, sid);
+                case 'perf': return getPerformanceReport(ctx);
+                case 'memory': return getMemoryUsage(ctx);
+                case 'errors': return getErrors(ctx, sid);
+                default:
+                    throw new Error(`Invalid level: ${level}. Must be one of: status, full, perf, memory, errors`);
             }
-            return result.trim();
         }
         default:
             throw new Error(`diagnostics module does not handle tool: ${name}`);