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

package/dist/server/tools/ai.js

@@ -1,73 +1,72 @@
 /**
  * ai domain — AI-powered feedback, pattern suggestion, and jamming.
  *
- * Owns (3 tools): get_pattern_feedback, suggest_pattern_from_audio,
- * jam_with.
+ * Owns one consolidated tool (`ai_assist(task=feedback|suggest|jam)`) —
+ * all three tasks share Gemini's rate limiting and auth.
  *
- * Per the #110 audit, these collapse into a single `ai_assist(task=...)`
- * tool — they all share Gemini's rate limiting and auth, so the merge
- * is natural. Deferred until external contracts stabilize.
- *
- * `jam_with` carries six private helpers that analyze the current
+ * The `jam` task carries six private helpers that analyze the current
  * pattern (tempo/key/style detection, layer detection, merge logic)
- * and that are used only by this tool. They live here.
+ * and that are used only here. They live in this module.
  */
 import { Logger } from '../../utils/Logger.js';
 const logger = new Logger();
-export const tools = [
-    {
-        name: 'get_pattern_feedback',
-        description: 'Get AI-powered creative feedback on the current pattern using Google Gemini. Analyzes pattern structure and optionally audio.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                includeAudio: { type: 'boolean', description: 'Include audio analysis (plays pattern briefly). Default: false' },
-                style: { type: 'string', description: 'Optional style hint for context (e.g., "techno", "ambient")' },
-            },
-        },
+const SESSION_ID_PROP = {
+    session_id: {
+        type: 'string',
+        description: 'Optional session ID (#108). Omit to use default session.',
     },
+};
+export const tools = [
     {
-        name: 'suggest_pattern_from_audio',
-        description: 'Analyze the currently playing audio and suggest a complementary Strudel pattern using Gemini AI. Extracts tempo, key, and spectral features locally, then uses AI to generate a matching pattern. Returns pattern text (not auto-executed).',
+        name: 'ai_assist',
+        description: 'Gemini-backed pattern assistance. ' +
+            'task=feedback returns creative critique on the current pattern (optionally with audio analysis). ' +
+            'task=suggest analyzes the currently playing audio and suggests a complementary Strudel pattern as text (not auto-executed). ' +
+            'task=jam generates a fresh layer (drums/bass/melody/pad/texture) and merges it into the current pattern, then auto-plays. ' +
+            'All three share Gemini auth + rate limiting. ' +
+            'Example: ai_assist({ task: "jam", layer: "bass" }). ' +
+            'Requires GEMINI_API_KEY env var. For non-AI pattern generation use generate_part; for full compositions use compose.',
         inputSchema: {
             type: 'object',
             properties: {
-                style: { type: 'string', description: 'Optional style hint (e.g., "ambient", "techno", "jazz")' },
+                task: { type: 'string', enum: ['feedback', 'suggest', 'jam'], description: 'Which AI task' },
+                // feedback args
+                includeAudio: { type: 'boolean', description: 'task=feedback: include audio analysis (default false)' },
+                style: { type: 'string', description: 'task=feedback/suggest: style hint' },
+                // suggest args
                 role: {
                     type: 'string',
                     enum: ['complement', 'bassline', 'melody', 'percussion'],
-                    description: 'What role the suggested pattern should fill. Default: complement',
+                    description: 'task=suggest: role the suggested pattern fills (default complement)',
                 },
-            },
-        },
-    },
-    {
-        name: 'jam_with',
-        description: 'AI generates a complementary layer to jam with your pattern. Analyzes current pattern to detect tempo, key, and existing layers, then generates a matching layer that fits musically.',
-        inputSchema: {
-            type: 'object',
-            properties: {
+                // jam args
                 layer: {
                     type: 'string',
                     enum: ['drums', 'bass', 'melody', 'pad', 'texture'],
-                    description: 'Type of layer to add: drums, bass, melody, pad, or texture',
+                    description: 'task=jam: layer type to generate',
                 },
-                style_hint: { type: 'string', description: 'Optional style guidance (e.g., "funky", "minimal", "atmospheric")' },
-                auto_play: { type: 'boolean', description: 'Start playback after adding layer (default: true)' },
+                style_hint: { type: 'string', description: 'task=jam: style guidance' },
+                auto_play: { type: 'boolean', description: 'task=jam: start playback after merge (default true)' },
+                ...SESSION_ID_PROP,
             },
-            required: ['layer'],
+            required: ['task'],
         },
     },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
 export async function execute(name, args, ctx) {
+    const sid = args?.session_id;
     switch (name) {
-        case 'get_pattern_feedback':
-            return await getPatternFeedback(args?.includeAudio || false, args?.style, ctx);
-        case 'suggest_pattern_from_audio':
-            return await suggestPatternFromAudio(args?.style, args?.role || 'complement', ctx);
-        case 'jam_with':
-            return await jamWith(args.layer, args.style_hint, args.auto_play, ctx);
+        case 'ai_assist': {
+            const t = args?.task;
+            switch (t) {
+                case 'feedback': return await getPatternFeedback(args?.includeAudio || false, args?.style, ctx, sid);
+                case 'suggest': return await suggestPatternFromAudio(args?.style, args?.role || 'complement', ctx, sid);
+                case 'jam': return await jamWith(args.layer, args.style_hint, args.auto_play, ctx, sid);
+                default:
+                    throw new Error(`Invalid task: ${t}. Must be one of: feedback, suggest, jam`);
+            }
+        }
         default:
             throw new Error(`ai module does not handle tool: ${name}`);
     }
@@ -75,14 +74,14 @@ export async function execute(name, args, ctx) {
 // ---------------------------------------------------------------------------
 // get_pattern_feedback
 // ---------------------------------------------------------------------------
-async function getPatternFeedback(includeAudio, style, ctx) {
+async function getPatternFeedback(includeAudio, style, ctx, sid) {
     if (!ctx.geminiService.isAvailable()) {
         return {
             gemini_available: false,
             error: 'Gemini API not configured. Set GEMINI_API_KEY environment variable to enable AI feedback.',
         };
     }
-    const pattern = await ctx.getCurrentPatternSafe();
+    const pattern = await ctx.getCurrentPatternSafe(sid);
     if (!pattern || pattern.trim().length === 0) {
         return { gemini_available: true, error: 'No pattern to analyze. Write a pattern first.' };
     }
@@ -98,9 +97,9 @@ async function getPatternFeedback(includeAudio, style, ctx) {
         }
         result.error = `Pattern analysis failed: ${message}`;
     }
-    if (includeAudio && ctx.isInitialized()) {
+    if (includeAudio && (sid || ctx.isInitialized())) {
         try {
-            const audioBlob = await captureAudioSampleForFeedback(ctx);
+            const audioBlob = await captureAudioSampleForFeedback(ctx, sid);
             if (audioBlob) {
                 result.audio_analysis = await ctx.geminiService.analyzeAudio(audioBlob, { style, duration: 5 });
             }
@@ -128,8 +127,8 @@ async function getPatternFeedback(includeAudio, style, ctx) {
  * analyzer's AudioContext and records 5 seconds without disturbing
  * the full AudioCaptureService lifecycle.
  */
-async function captureAudioSampleForFeedback(ctx) {
-    const page = ctx.controller.page;
+async function captureAudioSampleForFeedback(ctx, sid) {
+    const page = ctx.getController(sid).page;
     if (!page) {
         logger.warn('Cannot capture audio: controller page not available');
         return null;
@@ -154,7 +153,7 @@ async function captureAudioSampleForFeedback(ctx) {
                         try {
                             analyzer.analyser.disconnect(destination);
                         }
-                        catch { }
+                        catch { /* already disconnected */ }
                         if (chunks.length === 0) {
                             resolve(null);
                             return;
@@ -194,22 +193,23 @@ async function captureAudioSampleForFeedback(ctx) {
 // ---------------------------------------------------------------------------
 // suggest_pattern_from_audio
 // ---------------------------------------------------------------------------
-async function suggestPatternFromAudio(style, role, ctx) {
-    if (!ctx.isInitialized()) {
+async function suggestPatternFromAudio(style, role, ctx, sid) {
+    if (!sid && !ctx.isInitialized()) {
         return { error: 'Browser not initialized. Run init and play a pattern first.' };
     }
     if (!ctx.geminiService.isAvailable()) {
         return { error: 'Gemini API not configured. Set GEMINI_API_KEY to enable AI features.' };
     }
+    const controller = ctx.getController(sid);
     let bpm = 0, key = 'C', scale = 'major';
     try {
-        const tempoResult = await ctx.controller.detectTempo();
+        const tempoResult = await controller.detectTempo();
         if (tempoResult && tempoResult.bpm > 0)
             bpm = tempoResult.bpm;
     }
     catch { /* best effort */ }
     try {
-        const keyResult = await ctx.controller.detectKey();
+        const keyResult = await controller.detectKey();
         if (keyResult && keyResult.confidence > 0.1) {
             key = keyResult.key;
             scale = keyResult.scale;
@@ -251,7 +251,7 @@ Example patterns:
             style: style || 'auto',
             valid: validation.valid,
             validation_errors: validation.valid ? [] : validation.errors,
-            usage: 'Use write tool to load this pattern, then play to hear it.',
+            usage: 'Use edit_pattern({ mode: "write" }) to load this pattern, then playback({ action: "play" }) to hear it.',
         };
     }
     catch (error) {
@@ -263,7 +263,7 @@ Example patterns:
 // ---------------------------------------------------------------------------
 // jam_with
 // ---------------------------------------------------------------------------
-async function jamWith(layer, styleHint, autoPlay = true, ctx) {
+async function jamWith(layer, styleHint, autoPlay = true, ctx, sid) {
     const validLayers = ['drums', 'bass', 'melody', 'pad', 'texture'];
     if (!validLayers.includes(layer)) {
         return {
@@ -274,7 +274,7 @@ async function jamWith(layer, styleHint, autoPlay = true, ctx) {
             newLayer: '',
         };
     }
-    const currentPattern = await ctx.getCurrentPatternSafe();
+    const currentPattern = await ctx.getCurrentPatternSafe(sid);
     if (!currentPattern || currentPattern.trim().length === 0) {
         return {
             success: false,
@@ -308,9 +308,9 @@ async function jamWith(layer, styleHint, autoPlay = true, ctx) {
     }
     const mergedPattern = mergeLayerIntoPattern(currentPattern, newLayer, layer);
     try {
-        await ctx.writePatternSafe(mergedPattern);
-        if (autoPlay && ctx.isInitialized()) {
-            await ctx.controller.play();
+        await ctx.writePatternSafe(mergedPattern, sid);
+        if (autoPlay && (sid || ctx.isInitialized())) {
+            await ctx.getController(sid).play();
         }
         return {
             success: true,

package/dist/server/tools/analysis.js

@@ -1,129 +1,292 @@
 /**
- * analysis domain — audio analysis + pattern runtime validation.
+ * analysis domain — audio analysis + pattern validation (browser + local).
  *
- * Owns (6 tools): analyze, analyze_spectrum, analyze_rhythm,
- * detect_tempo, detect_key, validate_pattern_runtime.
+ * Owns (6 tools):
+ *   browser-required: analyze (include[] filter), validate_pattern_runtime
+ *   browser-free:     validate_pattern_local, analyze_pattern_local,
+ *                     query_pattern_events, transpile_pattern
  *
- * Post-consolidation (per #110 audit): a single `analyze` tool with
- * an `include[]` filter absorbs the 4 detection-specific tools.
- * `validate_pattern_runtime` stays separate — it's console/syntax
- * scraping, not audio DSP.
+ * The browser-free set runs against the in-process StrudelEngine and
+ * pairs naturally with validate_pattern_runtime (which monitors the
+ * actual Strudel console). They were orphan handlers — implementations
+ * present but not registered in tools/list — until #124.
  */
 import { InputValidator } from '../../utils/InputValidator.js';
+const SESSION_ID_PROP = {
+    session_id: {
+        type: 'string',
+        description: 'Optional session ID (#108). Omit to use default session.',
+    },
+};
 export const tools = [
     {
         name: 'analyze',
-        description: 'Complete audio analysis',
-        inputSchema: { type: 'object', properties: {} },
+        description: 'Audio analysis on the currently-playing pattern. ' +
+            'include=["all"] (default) returns the full spectrum + features object, matching the pre-consolidation behaviour. ' +
+            'include=["tempo"] returns only BPM with confidence. ' +
+            'include=["key"] returns detected key + scale + confidence. ' +
+            'include=["spectrum"] returns FFT features (bass, mid, treble, brightness, etc.). ' +
+            'include=["rhythm"] returns rhythm-only analysis (complexity, density, syncopation). ' +
+            'Combining values returns an object keyed by category, e.g. analyze({ include: ["tempo", "key"] }) → { tempo: {...}, key: {...} }. ' +
+            'Example: analyze({ include: ["tempo"] }) to cheaply re-check BPM during a session. ' +
+            'For static pattern analysis (no browser) use analyze_pattern_local; for runtime validation use validate_pattern_runtime.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                include: {
+                    type: 'array',
+                    items: { type: 'string', enum: ['all', 'spectrum', 'rhythm', 'tempo', 'key'] },
+                    description: 'Which analyses to return. Default ["all"] preserves pre-consolidation behaviour.',
+                },
+                ...SESSION_ID_PROP,
+            },
+        },
     },
     {
-        name: 'analyze_spectrum',
-        description: 'FFT spectrum analysis',
-        inputSchema: { type: 'object', properties: {} },
+        name: 'validate_pattern_runtime',
+        description: 'Validate pattern with runtime error checking (monitors Strudel console for errors)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Pattern code to validate' },
+                waitMs: { type: 'number', description: 'How long to wait for errors (default 500ms)' },
+                ...SESSION_ID_PROP,
+            },
+            required: ['pattern'],
+        },
     },
     {
-        name: 'analyze_rhythm',
-        description: 'Rhythm analysis',
-        inputSchema: { type: 'object', properties: {} },
+        name: 'validate_pattern_local',
+        description: 'Validate pattern syntax against the in-process StrudelEngine (no browser required)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Pattern code to validate' },
+            },
+            required: ['pattern'],
+        },
     },
     {
-        name: 'detect_tempo',
-        description: 'BPM detection',
-        inputSchema: { type: 'object', properties: {} },
+        name: 'analyze_pattern_local',
+        description: 'Static analysis (events/cycle, complexity, optional BPM) without browser playback',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Pattern code to analyze' },
+            },
+            required: ['pattern'],
+        },
     },
     {
-        name: 'detect_key',
-        description: 'Key detection',
-        inputSchema: { type: 'object', properties: {} },
+        name: 'query_pattern_events',
+        description: 'Enumerate events the pattern would emit between two cycle indices (max 16 cycles)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Pattern code to query' },
+                start: { type: 'number', description: 'Start cycle (default 0)' },
+                end: { type: 'number', description: 'End cycle (default 1)' },
+            },
+            required: ['pattern'],
+        },
     },
     {
-        name: 'validate_pattern_runtime',
-        description: 'Validate pattern with runtime error checking (monitors Strudel console for errors)',
+        name: 'transpile_pattern',
+        description: 'Transpile pattern source via StrudelEngine; returns transpiled code or syntax error',
         inputSchema: {
             type: 'object',
             properties: {
-                pattern: { type: 'string', description: 'Pattern code to validate' },
-                waitMs: { type: 'number', description: 'How long to wait for errors (default 500ms)' },
+                pattern: { type: 'string', description: 'Pattern code to transpile' },
             },
             required: ['pattern'],
         },
     },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
+// Tools in this module that do NOT require a browser session.
+const LOCAL_ENGINE_TOOLS = new Set([
+    'validate_pattern_local',
+    'analyze_pattern_local',
+    'query_pattern_events',
+    'transpile_pattern',
+]);
+async function getSpectrum(controller) {
+    const spectrum = await controller.analyzeAudio();
+    return spectrum.features || spectrum;
+}
+async function getRhythm(controller) {
+    return await controller.analyzeRhythm();
+}
+async function getTempo(controller) {
+    try {
+        const tempoAnalysis = await controller.detectTempo();
+        if (!tempoAnalysis || tempoAnalysis.bpm === 0) {
+            return {
+                bpm: 0,
+                confidence: 0,
+                message: 'No tempo detected. Ensure audio is playing and has a clear rhythmic pattern.',
+            };
+        }
+        return {
+            bpm: tempoAnalysis.bpm,
+            confidence: Math.round(tempoAnalysis.confidence * 100) / 100,
+            method: tempoAnalysis.method,
+            message: `Detected ${tempoAnalysis.bpm} BPM with ${Math.round(tempoAnalysis.confidence * 100)}% confidence`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { bpm: 0, confidence: 0, error: message || 'Tempo detection failed' };
+    }
+}
+async function getKey(controller) {
+    try {
+        const keyAnalysis = await controller.detectKey();
+        if (!keyAnalysis || keyAnalysis.confidence < 0.1) {
+            return {
+                key: 'Unknown',
+                scale: 'unknown',
+                confidence: 0,
+                message: 'No clear key detected. Ensure audio is playing and has tonal content.',
+            };
+        }
+        const result = {
+            key: keyAnalysis.key,
+            scale: keyAnalysis.scale,
+            confidence: Math.round(keyAnalysis.confidence * 100) / 100,
+            message: `Detected ${keyAnalysis.key} ${keyAnalysis.scale} with ${Math.round(keyAnalysis.confidence * 100)}% confidence`,
+        };
+        if (keyAnalysis.alternatives && keyAnalysis.alternatives.length > 0) {
+            result.alternatives = keyAnalysis.alternatives.map((alt) => ({
+                key: alt.key,
+                scale: alt.scale,
+                confidence: Math.round(alt.confidence * 100) / 100,
+            }));
+        }
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { key: 'Unknown', scale: 'unknown', confidence: 0, error: message || 'Key detection failed' };
+    }
+}
+async function doAnalyze(args, controller) {
+    const includeRaw = args?.include;
+    const include = Array.isArray(includeRaw) && includeRaw.length > 0
+        ? includeRaw
+        : ['all'];
+    for (const v of include) {
+        if (!['all', 'spectrum', 'rhythm', 'tempo', 'key'].includes(v)) {
+            throw new Error(`Invalid include value: ${v}. Must be one of: all, spectrum, rhythm, tempo, key`);
+        }
+    }
+    // include=['all'] is the most-common path and returns the unwrapped
+    // analyzeAudio result (no schema surprise vs old `analyze`).
+    if (include.includes('all')) {
+        return await controller.analyzeAudio();
+    }
+    // Otherwise return an object keyed by category, computed in parallel.
+    const tasks = {};
+    if (include.includes('spectrum'))
+        tasks.spectrum = getSpectrum(controller);
+    if (include.includes('rhythm'))
+        tasks.rhythm = getRhythm(controller);
+    if (include.includes('tempo'))
+        tasks.tempo = getTempo(controller);
+    if (include.includes('key'))
+        tasks.key = getKey(controller);
+    const entries = await Promise.all(Object.entries(tasks).map(async ([k, p]) => [k, await p]));
+    return Object.fromEntries(entries);
+}
 export async function execute(name, args, ctx) {
-    if (!ctx.isInitialized()) {
+    const sid = args?.session_id;
+    if (!LOCAL_ENGINE_TOOLS.has(name) && !sid && !ctx.isInitialized()) {
         return 'Browser not initialized. Run init first.';
     }
+    const controller = LOCAL_ENGINE_TOOLS.has(name) ? null : ctx.getController(sid);
     switch (name) {
         case 'analyze':
-            return await ctx.controller.analyzeAudio();
-        case 'analyze_spectrum': {
-            const spectrum = await ctx.controller.analyzeAudio();
-            return spectrum.features || spectrum;
+            return await doAnalyze(args, controller);
+        case 'validate_pattern_runtime': {
+            InputValidator.validateStringLength(args.pattern, 'pattern', 10000, false);
+            const validation = await controller.validatePatternRuntime(args.pattern, args.waitMs || 500);
+            if (validation.valid) {
+                return '✅ Pattern valid - no runtime errors detected';
+            }
+            return `❌ Pattern has runtime errors:\n${validation.errors.join('\n')}\n` +
+                (validation.warnings.length > 0 ? `\nWarnings:\n${validation.warnings.join('\n')}` : '');
         }
-        case 'analyze_rhythm':
-            return await ctx.controller.analyzeRhythm();
-        case 'detect_tempo': {
-            try {
-                const tempoAnalysis = await ctx.controller.detectTempo();
-                if (!tempoAnalysis || tempoAnalysis.bpm === 0) {
-                    return {
-                        bpm: 0,
-                        confidence: 0,
-                        message: 'No tempo detected. Ensure audio is playing and has a clear rhythmic pattern.',
-                    };
-                }
-                return {
-                    bpm: tempoAnalysis.bpm,
-                    confidence: Math.round(tempoAnalysis.confidence * 100) / 100,
-                    method: tempoAnalysis.method,
-                    message: `Detected ${tempoAnalysis.bpm} BPM with ${Math.round(tempoAnalysis.confidence * 100)}% confidence`,
-                };
+        case 'validate_pattern_local': {
+            InputValidator.validateStringLength(args.pattern, 'pattern', 10000, false);
+            const localValidation = ctx.strudelEngine.validate(args.pattern);
+            return {
+                valid: localValidation.valid,
+                errors: localValidation.errors,
+                warnings: localValidation.warnings,
+                suggestions: localValidation.suggestions,
+                errorLocation: localValidation.errorLocation,
+                message: localValidation.valid
+                    ? '✅ Pattern is valid'
+                    : `❌ Pattern has ${localValidation.errors.length} error(s)`,
+            };
+        }
+        case 'analyze_pattern_local': {
+            InputValidator.validateStringLength(args.pattern, 'pattern', 10000, false);
+            const patternMetadata = ctx.strudelEngine.analyzePattern(args.pattern);
+            return {
+                ...patternMetadata,
+                message: `Pattern analysis: ${patternMetadata.eventsPerCycle} events/cycle, ` +
+                    `complexity ${(patternMetadata.complexity * 100).toFixed(0)}%` +
+                    (patternMetadata.bpm ? `, ${patternMetadata.bpm} BPM` : ''),
+            };
+        }
+        case 'query_pattern_events': {
+            InputValidator.validateStringLength(args.pattern, 'pattern', 10000, false);
+            const startCycle = args.start ?? 0;
+            const endCycle = args.end ?? 1;
+            if (startCycle >= endCycle) {
+                return { error: 'Start must be less than end' };
             }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                return { bpm: 0, confidence: 0, error: message || 'Tempo detection failed' };
+            if (endCycle - startCycle > 16) {
+                return { error: 'Maximum range is 16 cycles to prevent excessive output' };
             }
-        }
-        case 'detect_key': {
             try {
-                const keyAnalysis = await ctx.controller.detectKey();
-                if (!keyAnalysis || keyAnalysis.confidence < 0.1) {
-                    return {
-                        key: 'Unknown',
-                        scale: 'unknown',
-                        confidence: 0,
-                        message: 'No clear key detected. Ensure audio is playing and has tonal content.',
-                    };
-                }
-                const result = {
-                    key: keyAnalysis.key,
-                    scale: keyAnalysis.scale,
-                    confidence: Math.round(keyAnalysis.confidence * 100) / 100,
-                    message: `Detected ${keyAnalysis.key} ${keyAnalysis.scale} with ${Math.round(keyAnalysis.confidence * 100)}% confidence`,
+                const events = ctx.strudelEngine.queryEvents(args.pattern, startCycle, endCycle);
+                return {
+                    count: events.length,
+                    range: { start: startCycle, end: endCycle },
+                    events: events.map((e) => ({
+                        value: e.value,
+                        start: e.start,
+                        end: e.end,
+                        duration: e.end - e.start,
+                    })),
                 };
-                if (keyAnalysis.alternatives && keyAnalysis.alternatives.length > 0) {
-                    result.alternatives = keyAnalysis.alternatives.map((alt) => ({
-                        key: alt.key,
-                        scale: alt.scale,
-                        confidence: Math.round(alt.confidence * 100) / 100,
-                    }));
-                }
-                return result;
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                return { key: 'Unknown', scale: 'unknown', confidence: 0, error: message || 'Key detection failed' };
+                return {
+                    error: message,
+                    suggestion: 'Check pattern syntax with validate_pattern_local first',
+                };
             }
         }
-        case 'validate_pattern_runtime': {
+        case 'transpile_pattern': {
             InputValidator.validateStringLength(args.pattern, 'pattern', 10000, false);
-            const validation = await ctx.controller.validatePatternRuntime(args.pattern, args.waitMs || 500);
-            if (validation.valid) {
-                return '✅ Pattern valid - no runtime errors detected';
+            const transpileResult = ctx.strudelEngine.transpile(args.pattern);
+            if (transpileResult.success) {
+                return {
+                    success: true,
+                    transpiledCode: transpileResult.transpiledCode,
+                    message: 'Pattern transpiled successfully',
+                };
             }
-            return `❌ Pattern has runtime errors:\n${validation.errors.join('\n')}\n` +
-                (validation.warnings.length > 0 ? `\nWarnings:\n${validation.warnings.join('\n')}` : '');
+            return {
+                success: false,
+                error: transpileResult.error,
+                errorLocation: transpileResult.errorLocation,
+                message: 'Transpilation failed',
+            };
         }
         default:
             throw new Error(`analysis module does not handle tool: ${name}`);