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

package/dist/AudioAnalyzer.js

@@ -625,7 +625,6 @@ export class AudioAnalyzer {
             return 0;
         let syncopationScore = 0;
         for (let i = 1; i < onsets.length; i++) {
-            const interval = onsets[i] - onsets[i - 1];
             const phase = (onsets[i] % (meanInterval * 4)) / meanInterval;
             // Check if onset is on an off-beat (not on 0, 1, 2, 3)
             const nearestBeat = Math.round(phase);

package/dist/PatternStore.js

@@ -99,7 +99,6 @@ export class PatternStore {
         }
         try {
             const files = await fs.readdir(this.basePath);
-            const patterns = [];
             // Parallel file reading for better performance
             const readPromises = files
                 .filter(file => file.endsWith('.json'))

package/dist/server/resources.js

@@ -0,0 +1,175 @@
+/**
+ * MCP resources — read-only catalogs the server exposes alongside tools.
+ *
+ * From #131 (originated as finding #6 in @nareto's audit #127): an agent
+ * shouldn't have to spend tool calls just to discover what bundled
+ * patterns exist or which styles the generator accepts. Surface those
+ * catalogs as MCP resources so they can be listed once and reasoned
+ * about without round-trips.
+ *
+ * Four resources:
+ *   strudel://examples              — bundled patterns under patterns/examples
+ *   strudel://patterns              — user-saved patterns from PatternStore
+ *   strudel://styles                — supported genres + default BPM
+ *   strudel://docs/tools            — tool quick-reference, one line each
+ *
+ * All payloads are JSON text. URIs are stable; content for examples and
+ * styles is bundled with the build and effectively immutable per release.
+ * Patterns is the only one that mutates at runtime.
+ */
+import { promises as fs } from 'node:fs';
+import { join, basename } from 'node:path';
+import { diagnosticsModule } from './tools/diagnostics.js';
+import { playbackModule } from './tools/playback.js';
+import { storageModule } from './tools/storage.js';
+import { historyModule } from './tools/history.js';
+import { analysisModule } from './tools/analysis.js';
+import { editorModule } from './tools/editor.js';
+import { transformModule } from './tools/transform.js';
+import { generateModule } from './tools/generate.js';
+import { sessionModule } from './tools/session.js';
+import { captureModule } from './tools/capture.js';
+import { aiModule } from './tools/ai.js';
+import { composeModule } from './tools/compose.js';
+export const resources = [
+    {
+        uri: 'strudel://examples',
+        name: 'Bundled example patterns',
+        description: 'Curated example patterns shipped with the server, organised by genre',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'strudel://patterns',
+        name: 'Saved patterns',
+        description: 'Patterns saved by the user via the `save` tool, with tags and timestamps',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'strudel://styles',
+        name: 'Supported styles',
+        description: 'Genres the generator accepts, with their default tempos',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'strudel://docs/tools',
+        name: 'Tool quick-reference',
+        description: 'Compact list of every registered MCP tool with a one-line description',
+        mimeType: 'application/json',
+    },
+];
+const resourceUris = new Set(resources.map(r => r.uri));
+export function isResourceUri(uri) {
+    return resourceUris.has(uri);
+}
+/**
+ * Default tempos for the supported style set. Kept in sync with
+ * compose.ts:TEMPO_BY_STYLE — both grow together when a new genre
+ * lands. Future cleanup (#120 aftermath): single source of truth.
+ */
+const STYLE_DEFAULTS = {
+    techno: 130,
+    house: 125,
+    dnb: 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,
+};
+const TOOL_MODULES = [
+    editorModule,
+    playbackModule,
+    transformModule,
+    generateModule,
+    analysisModule,
+    storageModule,
+    historyModule,
+    diagnosticsModule,
+    composeModule,
+    aiModule,
+    captureModule,
+    sessionModule,
+];
+async function readExamples(examplesDir) {
+    const entries = await fs.readdir(examplesDir, { withFileTypes: true });
+    const genres = entries.filter(e => e.isDirectory()).map(e => e.name);
+    const items = [];
+    for (const genre of genres) {
+        const dir = join(examplesDir, genre);
+        const files = await fs.readdir(dir);
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const raw = await fs.readFile(join(dir, file), 'utf-8');
+                const data = JSON.parse(raw);
+                items.push({
+                    name: data.name ?? basename(file, '.json'),
+                    genre: data.genre ?? genre,
+                    bpm: data.bpm,
+                    key: data.key,
+                    tags: data.tags ?? [],
+                    description: data.description,
+                });
+            }
+            catch {
+                // Skip malformed example files rather than failing the whole list.
+            }
+        }
+    }
+    items.sort((a, b) => a.genre.localeCompare(b.genre) || a.name.localeCompare(b.name));
+    return { count: items.length, examples: items };
+}
+async function readSavedPatterns(store) {
+    const patterns = await store.list();
+    const items = patterns.map(p => ({
+        name: p.name,
+        tags: p.tags,
+        timestamp: p.timestamp,
+        contentPreview: p.content.length > 200 ? p.content.slice(0, 200) + '...' : p.content,
+    }));
+    return { count: items.length, patterns: items };
+}
+function readStyles() {
+    const items = Object.entries(STYLE_DEFAULTS)
+        .map(([name, defaultBpm]) => ({ name, defaultBpm }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return { count: items.length, styles: items };
+}
+function readToolDocs() {
+    const items = TOOL_MODULES.flatMap(m => m.tools.map(t => ({ name: t.name, description: t.description })));
+    items.unshift({ name: 'init', description: 'Initialize Strudel in browser' });
+    items.sort((a, b) => a.name.localeCompare(b.name));
+    return { count: items.length, tools: items };
+}
+export async function readResource(uri, ctx) {
+    let data;
+    switch (uri) {
+        case 'strudel://examples':
+            data = await readExamples(ctx.examplesDir);
+            break;
+        case 'strudel://patterns':
+            data = await readSavedPatterns(ctx.store);
+            break;
+        case 'strudel://styles':
+            data = readStyles();
+            break;
+        case 'strudel://docs/tools':
+            data = readToolDocs();
+            break;
+        default:
+            throw new Error(`Unknown resource URI: ${uri}`);
+    }
+    return {
+        uri,
+        mimeType: 'application/json',
+        text: JSON.stringify(data, null, 2),
+    };
+}