@williamzujkowski/live-coding-music-mcp 1.0.0

package/dist/server/tools/history.js

@@ -0,0 +1,196 @@
+/**
+ * history domain — undo/redo stacks and the pattern history browser.
+ *
+ * Owns (5 tools): undo, redo, list_history, restore_history,
+ * compare_patterns. Post-consolidation target per the #110 audit:
+ * single `history` tool with an `action` enum. For now we keep the
+ * individual verbs.
+ *
+ * The history module mutates the three state arrays (undoStack,
+ * redoStack, historyStack) passed through ctx.history. The outer
+ * server pushes onto these arrays on write/append/insert/replace/clear,
+ * so all mutations share the same underlying storage.
+ */
+export const tools = [
+    {
+        name: 'undo',
+        description: 'Undo last action',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'redo',
+        description: 'Redo action',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'list_history',
+        description: 'List recent pattern history with timestamps and previews',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Maximum entries to return (default: 10)' },
+            },
+        },
+    },
+    {
+        name: 'restore_history',
+        description: 'Restore a previous pattern from history by ID',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'number', description: 'History entry ID to restore' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'compare_patterns',
+        description: 'Compare two patterns from history showing differences',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id1: { type: 'number', description: 'First pattern ID' },
+                id2: { type: 'number', description: 'Second pattern ID (default: current pattern)' },
+            },
+            required: ['id1'],
+        },
+    },
+];
+export const toolNames = new Set(tools.map(t => t.name));
+function formatTimeAgo(date) {
+    const seconds = Math.floor((new Date().getTime() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86400)}d ago`;
+}
+function generateDiff(a, b) {
+    const l1 = a.split('\n');
+    const l2 = b.split('\n');
+    const out = [];
+    const max = Math.max(l1.length, l2.length);
+    for (let i = 0; i < max; i++) {
+        const x = l1[i] || '';
+        const y = l2[i] || '';
+        if (x === y) {
+            out.push(`  ${x}`);
+        }
+        else {
+            if (x)
+                out.push(`- ${x}`);
+            if (y)
+                out.push(`+ ${y}`);
+        }
+    }
+    return out;
+}
+function summarizeDiff(a, b) {
+    const l1 = a.split('\n');
+    const l2 = b.split('\n');
+    let added = 0, removed = 0, changed = 0;
+    const max = Math.max(l1.length, l2.length);
+    for (let i = 0; i < max; i++) {
+        const x = l1[i];
+        const y = l2[i];
+        if (x === undefined && y !== undefined)
+            added++;
+        else if (x !== undefined && y === undefined)
+            removed++;
+        else if (x !== y)
+            changed++;
+    }
+    return { linesAdded: added, linesRemoved: removed, linesChanged: changed, charsDiff: b.length - a.length };
+}
+export async function execute(name, args, ctx) {
+    const { undoStack, redoStack, historyStack, maxHistory } = ctx.history;
+    switch (name) {
+        case 'undo': {
+            if (!ctx.isInitialized())
+                return 'Browser not initialized. Run init first.';
+            if (undoStack.length === 0)
+                return 'Nothing to undo';
+            const current = await ctx.controller.getCurrentPattern();
+            redoStack.push(current);
+            if (redoStack.length > maxHistory)
+                redoStack.shift();
+            const previous = undoStack.pop();
+            await ctx.controller.writePattern(previous);
+            return 'Undone';
+        }
+        case 'redo': {
+            if (!ctx.isInitialized())
+                return 'Browser not initialized. Run init first.';
+            if (redoStack.length === 0)
+                return 'Nothing to redo';
+            const current = await ctx.controller.getCurrentPattern();
+            undoStack.push(current);
+            if (undoStack.length > maxHistory)
+                undoStack.shift();
+            const next = redoStack.pop();
+            await ctx.controller.writePattern(next);
+            return 'Redone';
+        }
+        case 'list_history': {
+            if (historyStack.length === 0) {
+                return 'No pattern history yet. Make some edits to build history.';
+            }
+            const limit = args?.limit || 10;
+            const recent = historyStack.slice(-limit).reverse();
+            return {
+                count: historyStack.length,
+                showing: recent.length,
+                entries: recent.map(e => ({
+                    id: e.id,
+                    preview: e.pattern.substring(0, 60) + (e.pattern.length > 60 ? '...' : ''),
+                    chars: e.pattern.length,
+                    action: e.action,
+                    timestamp: formatTimeAgo(e.timestamp),
+                })),
+            };
+        }
+        case 'restore_history': {
+            if (!ctx.isInitialized())
+                return 'Browser not initialized. Run init first.';
+            const entry = historyStack.find(e => e.id === args.id);
+            if (!entry) {
+                return `History entry #${args.id} not found. Use list_history to see available entries.`;
+            }
+            const current = await ctx.controller.getCurrentPattern();
+            undoStack.push(current);
+            if (undoStack.length > maxHistory)
+                undoStack.shift();
+            await ctx.controller.writePattern(entry.pattern);
+            return `Restored pattern from history #${args.id} (${formatTimeAgo(entry.timestamp)})`;
+        }
+        case 'compare_patterns': {
+            const first = historyStack.find(e => e.id === args.id1);
+            if (!first)
+                return `History entry #${args.id1} not found.`;
+            let second;
+            let label;
+            if (args.id2) {
+                const b = historyStack.find(e => e.id === args.id2);
+                if (!b)
+                    return `History entry #${args.id2} not found.`;
+                second = b.pattern;
+                label = `#${args.id2}`;
+            }
+            else {
+                second = await ctx.getCurrentPatternSafe();
+                label = 'current';
+            }
+            return {
+                pattern1: { id: args.id1, chars: first.pattern.length },
+                pattern2: { id: label, chars: second.length },
+                diff: generateDiff(first.pattern, second),
+                summary: summarizeDiff(first.pattern, second),
+            };
+        }
+        default:
+            throw new Error(`history module does not handle tool: ${name}`);
+    }
+}
+export const historyModule = { tools, toolNames, execute };

package/dist/server/tools/playback.js

@@ -0,0 +1,41 @@
+/**
+ * playback domain — transport controls (play, pause, stop).
+ *
+ * Owns (3 tools): play, pause, stop. Post-consolidation target
+ * (#110 audit, #120 epic): single `playback` tool with action enum.
+ * For now we keep the individual verbs and only extract them out of
+ * server.ts.
+ *
+ * Initialization checks happen upstream via requiresInitialization()
+ * in StrudelMCPServer — handlers here assume the browser is ready.
+ */
+export const tools = [
+    {
+        name: 'play',
+        description: 'Start playing pattern',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'pause',
+        description: 'Pause playback',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'stop',
+        description: 'Stop playback',
+        inputSchema: { type: 'object', properties: {} },
+    },
+];
+export const toolNames = new Set(tools.map(t => t.name));
+export async function execute(name, _args, ctx) {
+    switch (name) {
+        case 'play':
+            return await ctx.controller.play();
+        case 'pause':
+        case 'stop':
+            return await ctx.controller.stop();
+        default:
+            throw new Error(`playback module does not handle tool: ${name}`);
+    }
+}
+export const playbackModule = { tools, toolNames, execute };

package/dist/server/tools/session.js

@@ -0,0 +1,115 @@
+/**
+ * session domain — multi-session lifecycle management.
+ *
+ * Owns (4 tools): create_session, destroy_session, list_sessions,
+ * switch_session. Per the #110 audit, these collapse into a single
+ * `session` tool with an `action` enum post-split. `init` stays
+ * separate — it's the global bootstrap, not a session operation.
+ *
+ * `show_browser` also stays in server.ts for now until it moves into
+ * a `browser_window` module (per audit) alongside `screenshot`.
+ */
+import { InputValidator } from '../../utils/InputValidator.js';
+export const tools = [
+    {
+        name: 'create_session',
+        description: 'Create a new isolated Strudel browser session. Sessions share one browser but have isolated contexts.',
+        inputSchema: {
+            type: 'object',
+            properties: { session_id: { type: 'string', description: 'Unique identifier for the session' } },
+            required: ['session_id'],
+        },
+    },
+    {
+        name: 'destroy_session',
+        description: 'Close and destroy a Strudel session, releasing its resources.',
+        inputSchema: {
+            type: 'object',
+            properties: { session_id: { type: 'string', description: 'Session identifier to destroy' } },
+            required: ['session_id'],
+        },
+    },
+    {
+        name: 'list_sessions',
+        description: 'List all active Strudel sessions with their metadata.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'switch_session',
+        description: 'Change the default session used by other tools.',
+        inputSchema: {
+            type: 'object',
+            properties: { session_id: { type: 'string', description: 'Session identifier to set as default' } },
+            required: ['session_id'],
+        },
+    },
+];
+export const toolNames = new Set(tools.map(t => t.name));
+export async function execute(name, args, ctx) {
+    const sm = ctx.sessionManager;
+    switch (name) {
+        case 'create_session': {
+            InputValidator.validateStringLength(args.session_id, 'session_id', 100, false);
+            try {
+                await sm.createSession(args.session_id);
+                return {
+                    success: true,
+                    session_id: args.session_id,
+                    message: `Session '${args.session_id}' created successfully`,
+                    total_sessions: sm.getSessionCount(),
+                    max_sessions: sm.getMaxSessions(),
+                };
+            }
+            catch (error) {
+                return { success: false, error: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        case 'destroy_session': {
+            InputValidator.validateStringLength(args.session_id, 'session_id', 100, false);
+            try {
+                await sm.destroySession(args.session_id);
+                return {
+                    success: true,
+                    session_id: args.session_id,
+                    message: `Session '${args.session_id}' destroyed`,
+                    remaining_sessions: sm.getSessionCount(),
+                };
+            }
+            catch (error) {
+                return { success: false, error: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        case 'list_sessions': {
+            const info = sm.getSessionsInfo();
+            return {
+                count: info.length,
+                max_sessions: sm.getMaxSessions(),
+                default_session: sm.getDefaultSessionId(),
+                sessions: info.map(s => ({
+                    id: s.id,
+                    created: s.created.toISOString(),
+                    last_activity: s.lastActivity.toISOString(),
+                    is_playing: s.isPlaying,
+                    is_default: s.id === sm.getDefaultSessionId(),
+                })),
+            };
+        }
+        case 'switch_session': {
+            InputValidator.validateStringLength(args.session_id, 'session_id', 100, false);
+            try {
+                sm.setDefaultSession(args.session_id);
+                return {
+                    success: true,
+                    default_session: args.session_id,
+                    message: `Default session switched to '${args.session_id}'`,
+                };
+            }
+            catch (error) {
+                return { success: false, error: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        default:
+            throw new Error(`session module does not handle tool: ${name}`);
+    }
+}
+export const sessionModule = { tools, toolNames, execute };

package/dist/server/tools/storage.js

@@ -0,0 +1,77 @@
+/**
+ * storage domain — pattern persistence (save, load, list).
+ *
+ * Owns (3 tools): save, load, list. Post-consolidation target per the
+ * #110 audit: single `pattern_store` tool with `action` enum + params,
+ * which also resolves the `list` / `list_sessions` naming collision.
+ * For now we keep the individual verbs.
+ */
+import { InputValidator } from '../../utils/InputValidator.js';
+export const tools = [
+    {
+        name: 'save',
+        description: 'Save pattern with metadata',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Pattern name' },
+                tags: { type: 'array', items: { type: 'string' } },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'load',
+        description: 'Load saved pattern',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Pattern name' },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'list',
+        description: 'List saved patterns',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tag: { type: 'string', description: 'Filter by tag' },
+            },
+        },
+    },
+];
+export const toolNames = new Set(tools.map(t => t.name));
+export async function execute(name, args, ctx) {
+    switch (name) {
+        case 'save': {
+            InputValidator.validateStringLength(args.name, 'name', 255, false);
+            const toSave = await ctx.getCurrentPatternSafe();
+            if (!toSave) {
+                return 'No pattern to save';
+            }
+            await ctx.store.save(args.name, toSave, args.tags || []);
+            return `Pattern saved as "${args.name}"`;
+        }
+        case 'load': {
+            InputValidator.validateStringLength(args.name, 'name', 255, false);
+            const saved = await ctx.store.load(args.name);
+            if (saved) {
+                await ctx.writePatternSafe(saved.content);
+                return `Loaded pattern "${args.name}"`;
+            }
+            return `Pattern "${args.name}" not found`;
+        }
+        case 'list': {
+            if (args?.tag) {
+                InputValidator.validateStringLength(args.tag, 'tag', 100, false);
+            }
+            const patterns = await ctx.store.list(args?.tag);
+            return patterns.map(p => `• ${p.name} [${p.tags.join(', ')}] - ${p.timestamp}`).join('\n') || 'No patterns found';
+        }
+        default:
+            throw new Error(`storage module does not handle tool: ${name}`);
+    }
+}
+export const storageModule = { tools, toolNames, execute };