@williamzujkowski/live-coding-music-mcp 3.0.0 → 4.1.0

package/dist/utils/Tempo.js

@@ -0,0 +1,143 @@
+/**
+ * Tempo units, in one place.
+ *
+ * Strudel's tempo calls count CYCLES, not beats: `setcpm(n)` is n cycles
+ * per minute, `setcps(y)` is y cycles per second. Every pattern this
+ * project generates or imports is one bar of 4/4 per cycle, so a beat is
+ * a quarter of a cycle and the conversion is a factor of four.
+ *
+ * That factor was wrong in five places before anyone measured it (#395,
+ * #397): three writers with three different divisors, and two readers
+ * with two different regexes. It lives here now so the next call site
+ * inherits the decision instead of re-deriving it.
+ */
+/**
+ * Beats in one bar: the meter. Everything here is 4/4, and MIDI import
+ * lays other meters onto 4/4 bars rather than honouring them (#336).
+ */
+export const BEATS_PER_BAR = 4;
+/**
+ * Bars in one cycle: this project's convention, not Strudel's rule.
+ *
+ * Strudel lets a cycle be any length. Everything generated or imported
+ * here puts one bar in it — the generator's drum line is `s("bd*4, ...")`,
+ * the hand-written templates spell out eight eighth-notes with the snare
+ * on the backbeat, and `renderBars` wraps each bar so one cycle plays
+ * one bar.
+ *
+ * This is the assumption that was wrong three different ways before
+ * anyone measured it: one writer assumed one beat per cycle, another two
+ * bars, a third got it right. Named separately from the meter because
+ * they are separate claims that happen to multiply to four.
+ */
+export const BARS_PER_CYCLE = 1;
+/**
+ * Beats in one cycle — the tempo conversion factor.
+ *
+ * The tests assert the structure this rests on, so changing the bar
+ * fails loudly rather than silently rescaling every tempo.
+ */
+export const BEATS_PER_CYCLE = BEATS_PER_BAR * BARS_PER_CYCLE;
+/**
+ * A tempo call and its arguments.
+ *
+ * `setcpm` and `setcps` only. The old `ai.ts` parser also accepted
+ * `setbpm`, and a cross-model reviewer called dropping it a silent
+ * regression — but `@strudel/core` binds `setCps`/`setcps` and
+ * `setCpm`/`setcpm` and nothing else; `setbpm` appears only as a
+ * keyword token in `@strudel/mini`'s grammar table. A pattern calling
+ * it does not run, so reading a tempo out of it would be inventing one.
+ * `StrudelEngineHelpers` had already excluded it on purpose; this makes
+ * that one decision instead of two. (`mergeLayerIntoPattern` still
+ * matches `setbpm` when it hunts for a tempo prefix — harmless, since
+ * it only decides where to splice, but it is the last reference left.)
+ *
+ * `(?<![\w$.])` so `resetcpm(120)` and `x.setcps(2)` are not tempo
+ * calls. Only digits, dots and `/` inside: this parses pattern text
+ * that arrived as a tool argument, and it never evaluates it.
+ */
+const TEMPO_CALL = /(?<![\w$.])set(cpm|cps)\s*\(\s*(\d+(?:\.\d+)?(?:\s*\/\s*\d+(?:\.\d+)?)*)\s*\)/i;
+/** Line and block comments, so a commented-out call is not read as one. */
+const COMMENTS = /\/\*[\s\S]*?\*\/|\/\/[^\n]*/g;
+/**
+ * The BPM a pattern's tempo call declares, or undefined when it has none.
+ *
+ * For a divided call this is the NUMERATOR — the number the author wrote
+ * — because that is the convention the shipped examples and the
+ * generator both follow: `setcpm(130/4)` means "130 BPM in 4/4", and the
+ * divisor is the beats-per-cycle conversion, not part of the tempo. Same
+ * for `setcps(174/60/4)`.
+ *
+ * The undivided forms are not symmetric, and deliberately so:
+ *
+ *   `setcpm(120)`  ->  120.  A bare cycles-per-minute number is what
+ *                      hand-written patterns mean by their tempo, and
+ *                      #341 already settled this.
+ *   `setcps(2)`    ->  480.  Nobody writing cycles per SECOND means BPM
+ *                      by it — `setcps(2)` is two cycles a second, and
+ *                      returning 2 as a tempo would be nonsense.
+ *
+ * Never eval — see `TEMPO_CALL`.
+ */
+export function declaredBpm(code) {
+    const parts = tempoParts(code);
+    if (parts === null)
+        return undefined;
+    // A divided call states its author's number first.
+    if (parts.values.length > 1)
+        return parts.values[0];
+    // An undivided one has to be read in its own unit. `cpm` hands back a
+    // number a person would recognise as their tempo; `cps` does not, so
+    // it converts.
+    return parts.unit === 'cps' ? convert(parts) : parts.values[0];
+}
+/**
+ * The BPM a pattern's tempo call implies, or undefined when it has none.
+ *
+ * Works the arithmetic through and converts, so it answers the question
+ * `declaredBpm` does not: for a correctly written pattern the two agree,
+ * and for the four-times-too-fast calls #395 fixed this one is four
+ * times larger. That gap is the whole bug, and a test that only reads
+ * the numerator cannot see it.
+ *
+ * **The tempo call only.** `.slow(2)` and `.fast(2)` rescale time and
+ * are not accounted for here — the shipped corpus pairs `setcpm(174/2)`
+ * with `.slow(2)` and plays at 174, which this reports as 348. Use it
+ * on patterns whose timing lives entirely in the tempo call, which is
+ * everything this project generates. `declaredBpm` is the right answer
+ * for a pattern someone else wrote.
+ */
+export function impliedBpm(code) {
+    const parts = tempoParts(code);
+    if (parts === null)
+        return undefined;
+    return convert(parts);
+}
+/** Work a parsed call through its arithmetic and into beats per minute. */
+function convert(parts) {
+    const value = parts.values.reduce((a, b) => a / b);
+    const cyclesPerMinute = parts.unit === 'cps' ? value * 60 : value;
+    return cyclesPerMinute * BEATS_PER_CYCLE;
+}
+/**
+ * Split a tempo call into its unit and its operands.
+ *
+ * Comments are stripped first. A parser that reads the first `setcpm` in
+ * the text will read a commented-out one, and "tempo taken from the
+ * wrong place" is the entire subject of #395 and #397 — this file does
+ * not get to repeat it.
+ *
+ * A zero anywhere rejects the whole call, divisor or numerator alike. A
+ * zero divisor is nonsense; a zero numerator is a stopped transport,
+ * which is not a tempo any caller here can use, and handing back 0 would
+ * only push the problem into `validateBPM` further down.
+ */
+function tempoParts(code) {
+    const match = TEMPO_CALL.exec(code.replace(COMMENTS, ' '));
+    if (match === null)
+        return null;
+    const values = match[2].split('/').map(part => Number.parseFloat(part.trim()));
+    if (values.some(n => !Number.isFinite(n) || n === 0))
+        return null;
+    return { unit: match[1].toLowerCase(), values };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamzujkowski/live-coding-music-mcp",
-  "version": "3.0.0",
+  "version": "4.1.0",
   "description": "MCP server (unofficial, fan project) for AI-assisted live-coding music via strudel.cc. Lets Claude drive pattern generation, audio analysis, and MIDI export through the Strudel browser REPL.",
   "type": "module",
   "main": "dist/index.js",
@@ -17,21 +17,27 @@
     "build": "tsc && npx tsx scripts/generate-tool-docs.ts",
     "dev": "tsx watch src/index.ts",
     "start": "node dist/index.js",
-    "test": "jest --coverage",
+    "test": "npm run test:fast && npm run test:browser",
     "test:nocov": "jest",
     "test:watch": "jest --watch",
     "test:integration": "node tests/strudel-integration.js",
-    "test:browser": "HEADLESS=true jest --testPathPattern=browser",
+    "test:browser": "HEADLESS=true jest --runInBand --forceExit --coverage=false --testPathPattern=__tests__/browser/",
     "lint": "eslint src --ext .ts",
     "format": "prettier --write \"src/**/*.ts\"",
     "docker:build": "docker build -t live-coding-music-mcp .",
     "docker:run": "docker-compose up",
-    "prepublishOnly": "npm run build && npm run test:nocov -- --testPathIgnorePatterns=browser",
+    "prepublishOnly": "npm run build && npm run test:nocov -- --testPathIgnorePatterns=__tests__/browser/",
     "prepare": "npm run build",
     "validate": "echo '{\"jsonrpc\":\"2.0\",\"method\":\"tools/list\",\"id\":1}' | node dist/index.js",
     "benchmark": "tsx src/__tests__/benchmarks/latency.benchmark.ts",
     "benchmark:gate": "tsx src/__tests__/benchmarks/latency.benchmark.ts --gate",
-    "clean": "rm -rf dist coverage"
+    "clean": "rm -rf dist coverage",
+    "test:sandbox": "tsx scripts/verify-sandbox.ts",
+    "test:envelopes": "npm run build && tsx scripts/verify-envelopes.ts",
+    "test:export-audio": "tsx scripts/verify-export-audio.ts",
+    "test:ai-transport": "tsx scripts/verify-ai-transport.ts",
+    "test:fast": "jest --coverage --testPathIgnorePatterns=__tests__/browser/",
+    "calibrate:tempo": "tsx scripts/calibrate-tempo.ts"
   },
   "dependencies": {
     "@google/generative-ai": "^0.24.1",
@@ -41,6 +47,7 @@
     "@strudel/tonal": "1.2.5",
     "@strudel/transpiler": "1.2.5",
     "@tonejs/midi": "^2.0.28",
+    "acorn": "8.16.0",
     "google-auth-library": "^10.5.0",
     "playwright": "^1.52.0"
   },
@@ -82,5 +89,10 @@
   "engines": {
     "node": ">=22.0.0",
     "npm": ">=10.0.0"
+  },
+  "overrides": {
+    "js-yaml@^3": "^3.15.1",
+    "js-yaml@^4": "^4.3.1",
+    "@babel/core": "^7.29.6"
   }
 }

package/dist/services/__mocks__/StrudelEngine.js

@@ -1,157 +0,0 @@
-/**
- * Mock StrudelEngine for Jest testing
- * Provides stub implementations for tests that don't need actual Strudel execution
- */
-export class StrudelEngine {
-    transpile(code) {
-        if (!code || code.trim().length === 0) {
-            return {
-                success: false,
-                error: 'Empty pattern',
-                errorLocation: { line: 1, column: 1, offset: 0 },
-            };
-        }
-        // Simple validation - check for basic syntax issues
-        if (code.includes('(') && !code.includes(')')) {
-            return {
-                success: false,
-                error: 'Unexpected end of input',
-                errorLocation: { line: 1, column: code.length, offset: code.length },
-            };
-        }
-        return {
-            success: true,
-            transpiledCode: `return /* mock transpiled */ ${code};`,
-            locations: [],
-        };
-    }
-    validate(code) {
-        const errors = [];
-        const warnings = [];
-        const suggestions = [];
-        if (!code || code.trim().length === 0) {
-            return {
-                valid: false,
-                errors: ['Pattern is empty'],
-                warnings: [],
-                suggestions: ['Add a pattern like: s("bd hh sd hh")'],
-            };
-        }
-        const transpileResult = this.transpile(code);
-        if (!transpileResult.success) {
-            return {
-                valid: false,
-                errors: [transpileResult.error || 'Syntax error'],
-                warnings,
-                suggestions: ['Check pattern syntax'],
-                errorLocation: transpileResult.errorLocation
-                    ? { line: transpileResult.errorLocation.line, column: transpileResult.errorLocation.column }
-                    : undefined,
-            };
-        }
-        // Check for common issues
-        const gainMatches = code.match(/\.gain\s*\(\s*(\d+(?:\.\d+)?)\s*\)/g);
-        if (gainMatches) {
-            for (const match of gainMatches) {
-                const value = parseFloat(match.match(/(\d+(?:\.\d+)?)/)?.[1] || '0');
-                if (value > 2) {
-                    warnings.push(`High gain value (${value}) may cause distortion`);
-                }
-            }
-        }
-        if (!/setcpm|setbpm|cpm|bpm/.test(code)) {
-            suggestions.push('Consider setting tempo with setcpm(120)');
-        }
-        return {
-            valid: errors.length === 0,
-            errors,
-            warnings,
-            suggestions,
-        };
-    }
-    queryEvents(code, start, end) {
-        const transpileResult = this.transpile(code);
-        if (!transpileResult.success) {
-            throw new Error(`Transpilation failed: ${transpileResult.error}`);
-        }
-        // Return mock events based on pattern content
-        const events = [];
-        const cycles = end - start;
-        // Simple mock - return 4 events per cycle for patterns containing s()
-        if (code.includes('s(')) {
-            const matches = code.match(/s\("([^"]+)"\)/);
-            if (matches) {
-                const sounds = matches[1].split(' ');
-                const eventsPerCycle = sounds.length;
-                const duration = 1 / eventsPerCycle;
-                for (let cycle = 0; cycle < cycles; cycle++) {
-                    for (let i = 0; i < sounds.length; i++) {
-                        events.push({
-                            value: { s: sounds[i] },
-                            start: start + cycle + i * duration,
-                            end: start + cycle + (i + 1) * duration,
-                            isWhole: true,
-                        });
-                    }
-                }
-            }
-        }
-        return events;
-    }
-    compile(code) {
-        const transpileResult = this.transpile(code);
-        if (!transpileResult.success) {
-            throw new Error(`Transpilation failed: ${transpileResult.error}`);
-        }
-        return {
-            queryArc: (start, end) => this.queryEvents(code, start, end),
-        };
-    }
-    analyzePattern(code) {
-        const metadata = {
-            eventsPerCycle: 0,
-            uniqueValues: [],
-            usesSound: false,
-            usesNote: false,
-            isStack: false,
-            functionsUsed: [],
-            complexity: 0,
-        };
-        // Extract BPM from setcpm
-        const bpmMatch = code.match(/setcpm\s*\(\s*(\d+(?:\.\d+)?)\s*\)/);
-        if (bpmMatch) {
-            metadata.bpm = parseFloat(bpmMatch[1]);
-        }
-        metadata.usesSound = /\bs\s*\(/.test(code) || /\bsound\s*\(/.test(code);
-        metadata.usesNote = /\bnote\s*\(/.test(code);
-        metadata.isStack = /\bstack\s*\(/.test(code);
-        // Extract function names
-        const funcMatches = code.match(/\b([a-z][a-zA-Z0-9_]*)\s*\(/g);
-        if (funcMatches) {
-            const funcNames = funcMatches.map(m => m.replace(/\s*\($/, ''));
-            metadata.functionsUsed = [...new Set(funcNames)];
-        }
-        try {
-            const events = this.queryEvents(code, 0, 1);
-            metadata.eventsPerCycle = events.length;
-            const values = events.map(e => {
-                if (typeof e.value === 'object' && e.value !== null) {
-                    return e.value.s || e.value.note || e.value.n || JSON.stringify(e.value);
-                }
-                return String(e.value);
-            });
-            metadata.uniqueValues = [...new Set(values)];
-            metadata.complexity = Math.min((events.length / 16) * 0.3 +
-                (metadata.uniqueValues.length / 8) * 0.2 +
-                (metadata.functionsUsed.length / 10) * 0.3 +
-                (metadata.isStack ? 0.1 : 0) +
-                (code.length / 500) * 0.1, 1);
-        }
-        catch {
-            metadata.complexity = Math.min((metadata.functionsUsed.length / 10) * 0.5 +
-                (code.length / 500) * 0.3 +
-                (metadata.isStack ? 0.2 : 0), 1);
-        }
-        return metadata;
-    }
-}

package/dist/types/index.js

@@ -1 +0,0 @@
-export {};