c64bridge 0.5.0

package/dist/audio/record_and_analyze_audio.js

@@ -0,0 +1,292 @@
+import { parseSidwave, midiToHz } from "../sidwave.js";
+export async function recordAndAnalyzeAudio(params) {
+    const duration = Math.max(0.5, Math.min(120, Number(params.durationSeconds || 0)));
+    if (!Number.isFinite(duration)) {
+        throw new Error("durationSeconds must be a number");
+    }
+    // Capture PCM from default microphone using naudiodon (PortAudio)
+    const sampleRate = 44100;
+    const channelCount = 1;
+    let portAudio;
+    try {
+        // Use non-literal specifier to avoid TS resolution during tests when module isn't present
+        const naModule = "naudiodon";
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        portAudio = await import(naModule);
+    }
+    catch (e) {
+        throw new Error("Audio backend not available. Please install 'naudiodon' dependencies (PortAudio). No external CLI tools are required.");
+    }
+    const input = new portAudio.AudioIO({
+        inOptions: {
+            channelCount,
+            sampleFormat: portAudio.SampleFormat16Bit,
+            sampleRate,
+            deviceId: -1,
+            closeOnError: true,
+        },
+    });
+    const chunks = [];
+    input.on("data", (chunk) => {
+        chunks.push(chunk);
+    });
+    await new Promise((resolve, reject) => {
+        try {
+            input.start();
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
+        setTimeout(() => {
+            try {
+                // Some versions expose quit(); others expose stop(). Try both safely.
+                if (typeof input.quit === "function")
+                    input.quit();
+                else if (typeof input.stop === "function")
+                    input.stop();
+            }
+            catch { }
+            resolve();
+        }, Math.round(duration * 1000));
+    });
+    const pcm16 = Buffer.concat(chunks);
+    const float32 = convertInt16ToFloat32(pcm16);
+    const analysis = await analyzePcm(float32, sampleRate, params.expectedSidwave);
+    return analysis;
+}
+function convertInt16ToFloat32(buf) {
+    const len = Math.floor(buf.length / 2);
+    const out = new Float32Array(len);
+    for (let i = 0; i < len; i += 1) {
+        const v = buf.readInt16LE(i * 2);
+        out[i] = v / 32768;
+    }
+    return out;
+}
+async function analyzePcm(signal, sampleRate, expectedSidwave) {
+    let Pitchfinder;
+    let Meyda = null;
+    try {
+        Pitchfinder = (await import("pitchfinder")).default ?? (await import("pitchfinder"));
+    }
+    catch (e) {
+        throw new Error("Missing dependency: pitchfinder");
+    }
+    try {
+        // meyda exports default in recent versions
+        const m = await import("meyda");
+        Meyda = m.default ?? m;
+    }
+    catch (e) {
+        // Optional: fall back to manual RMS if meyda is unavailable in environment
+        Meyda = null;
+    }
+    const windowSize = 2048;
+    const hopSize = 512;
+    const yin = Pitchfinder.YIN({ sampleRate });
+    const frames = [];
+    for (let i = 0; i + windowSize <= signal.length; i += hopSize) {
+        const win = signal.subarray(i, i + windowSize);
+        const rms = computeRms(win, Meyda, sampleRate, windowSize);
+        const minRms = 0.01; // simple noise gate
+        let freq = null;
+        if (rms >= minRms) {
+            try {
+                const f = yin(win);
+                if (Number.isFinite(f) && f > 20 && f < 8000)
+                    freq = f;
+            }
+            catch { }
+        }
+        frames.push({ t0: i / sampleRate, t1: (i + windowSize) / sampleRate, freq, rms });
+    }
+    const segments = groupSegments(frames, sampleRate);
+    // Map to detected notes with deviations
+    let expected;
+    if (expectedSidwave) {
+        try {
+            expected = parseSidwave(expectedSidwave);
+        }
+        catch {
+            expected = undefined;
+        }
+    }
+    const expectedMidiSet = extractExpectedMidiSet(expected);
+    const detected_notes = segments.map((seg) => {
+        if (seg.freq == null) {
+            return { note: null, frequency: null, duration_ms: Math.round(seg.duration * 1000), uncertain: true };
+        }
+        const midiMeasured = Math.round(69 + 12 * Math.log2(seg.freq / 440));
+        let deviation_cents;
+        if (expectedMidiSet && expectedMidiSet.length) {
+            const nearest = expectedMidiSet.reduce((best, m) => {
+                const hz = midiToHz(m);
+                const cents = 1200 * Math.log2(seg.freq / hz);
+                const d = Math.abs(cents);
+                return d < best.dist ? { midi: m, dist: d, cents } : best;
+            }, { midi: midiMeasured, dist: Infinity, cents: 0 });
+            deviation_cents = nearest.cents;
+        }
+        else {
+            const noteHz = midiToHz(midiMeasured);
+            deviation_cents = 1200 * Math.log2(seg.freq / noteHz);
+        }
+        const name = midiToName(midiMeasured);
+        return {
+            note: name,
+            frequency: round(seg.freq, 0.1),
+            duration_ms: Math.round(seg.duration * 1000),
+            deviation_cents: round(deviation_cents, 0.1),
+        };
+    });
+    // Basic BPM estimate from note change intervals
+    const onsetsSec = [];
+    let lastName = null;
+    let lastStart = null;
+    for (const seg of segments) {
+        const name = seg.freq ? midiToName(Math.round(69 + 12 * Math.log2(seg.freq / 440))) : null;
+        if (name && name !== lastName) {
+            onsetsSec.push(seg.t0);
+            lastName = name;
+            lastStart = seg.t0;
+        }
+    }
+    const ioi = [];
+    for (let i = 1; i < onsetsSec.length; i += 1)
+        ioi.push(onsetsSec[i] - onsetsSec[i - 1]);
+    const medianIoi = ioi.length ? median(ioi) : null;
+    const detected_bpm = medianIoi ? (60 / medianIoi) : null;
+    const avgDev = average(detected_notes
+        .map((n) => (n && typeof n.deviation_cents === "number" ? Math.abs(n.deviation_cents) : null))
+        .filter((x) => x != null));
+    const voices = [
+        { id: 1, detected_notes, average_deviation: avgDev },
+        { id: 2, detected_notes: [], average_deviation: null },
+        { id: 3, detected_notes: [], average_deviation: null },
+    ];
+    return {
+        sidwave: 1.0,
+        analysis: {
+            source: "microphone",
+            durationSeconds: signal.length / sampleRate,
+            voices,
+            global_metrics: {
+                average_pitch_deviation: avgDev,
+                detected_bpm: detected_bpm ? round(detected_bpm, 0.1) : null,
+            },
+        },
+    };
+}
+// Test-only helper: bypasses microphone capture and analyzes provided PCM buffer.
+export async function analyzePcmForTest(signal, sampleRate, expectedSidwave) {
+    return analyzePcm(signal, sampleRate, expectedSidwave);
+}
+function groupSegments(frames, _sampleRate) {
+    const segments = [];
+    let cur = null;
+    const freqTolCents = 35; // merge if within ~1/3 semitone
+    for (const f of frames) {
+        if (!cur) {
+            cur = { t0: f.t0, t1: f.t1, freq: f.freq };
+            continue;
+        }
+        if (f.freq == null && cur.freq == null) {
+            cur.t1 = f.t1;
+            continue;
+        }
+        if (f.freq != null && cur.freq != null) {
+            const cents = 1200 * Math.log2(f.freq / cur.freq);
+            if (Math.abs(cents) <= freqTolCents) {
+                // same note region
+                cur.t1 = f.t1;
+                // slight running average to stabilise
+                cur.freq = 0.9 * cur.freq + 0.1 * f.freq;
+                continue;
+            }
+        }
+        segments.push({ t0: cur.t0, t1: cur.t1, duration: cur.t1 - cur.t0, freq: cur.freq });
+        cur = { t0: f.t0, t1: f.t1, freq: f.freq };
+    }
+    if (cur)
+        segments.push({ t0: cur.t0, t1: cur.t1, duration: cur.t1 - cur.t0, freq: cur.freq });
+    return segments.filter((s) => s.duration > 0.01);
+}
+function midiToName(midi) {
+    const names = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+    const n = ((midi % 12) + 12) % 12;
+    const oct = Math.floor(midi / 12) - 1;
+    return `${names[n]}${oct}`;
+}
+function round(n, step = 1) {
+    return Math.round(n / step) * step;
+}
+function median(xs) {
+    const a = xs.slice().sort((x, y) => x - y);
+    const mid = Math.floor(a.length / 2);
+    return a.length % 2 ? a[mid] : (a[mid - 1] + a[mid]) / 2;
+}
+function average(xs) {
+    if (!xs.length)
+        return null;
+    const s = xs.reduce((acc, v) => acc + v, 0);
+    return s / xs.length;
+}
+function extractExpectedMidiSet(expected) {
+    if (!expected)
+        return null;
+    const set = new Set();
+    for (const v of expected.voices ?? []) {
+        const p = v.patterns ?? {};
+        for (const name of Object.keys(p)) {
+            const pat = p[name];
+            const notes = Array.isArray(pat?.notes) ? pat.notes : Array.isArray(pat?.groove) ? pat.groove : undefined;
+            if (!notes)
+                continue;
+            for (const n of notes) {
+                const m = noteNameToMidiSafe(n);
+                if (typeof m === "number")
+                    set.add(m);
+            }
+        }
+    }
+    return Array.from(set.values()).sort((a, b) => a - b);
+}
+function noteNameToMidiSafe(note) {
+    try {
+        // noteNameToMidi is imported indirectly via sidwave types; fallback if missing
+        const m = /^([A-Ga-g])([#b]?)(-?\d+)$/.exec((note || "").trim());
+        if (!m)
+            return undefined;
+        const letter = m[1].toUpperCase();
+        const accidental = m[2];
+        const octave = Number(m[3]);
+        const base = { C: 0, D: 2, E: 4, F: 5, G: 7, A: 9, B: 11 };
+        let semi = base[letter] ?? 0;
+        if (accidental === "#")
+            semi += 1;
+        if (accidental === "b")
+            semi -= 1;
+        const midi = (octave + 1) * 12 + semi;
+        return midi;
+    }
+    catch {
+        return undefined;
+    }
+}
+function computeRms(win, Meyda, sampleRate, bufferSize) {
+    try {
+        if (Meyda && typeof Meyda.extract === "function") {
+            const features = Meyda.extract(["rms"], win, { sampleRate, bufferSize });
+            const val = Number(features?.rms ?? 0);
+            if (Number.isFinite(val))
+                return val;
+        }
+    }
+    catch { }
+    // fallback
+    let sum = 0;
+    for (let i = 0; i < win.length; i += 1)
+        sum += win[i] * win[i];
+    return Math.sqrt(sum / Math.max(1, win.length));
+}

package/dist/basicConverter.js

@@ -0,0 +1,193 @@
+/*
+C64 Bridge - An MCP Server for the Commodore 64 Ultimate
+Copyright (C) 2025 Christian Gleissner
+
+Licensed under the GNU General Public License v2.0 or later.
+See <https://www.gnu.org/licenses/> for details.
+*/
+import { Buffer } from "node:buffer";
+import { asciiToPetscii, encodeStringWithNames } from "./petscii.js";
+const DEFAULT_START_ADDRESS = 0x0801;
+const REM_TOKEN = 0x8f;
+const TOKEN_TABLE = buildTokenTable();
+export function basicToPrg(source, options) {
+    const startAddress = options?.startAddress ?? DEFAULT_START_ADDRESS;
+    const normalizedSource = normalize(source);
+    const lines = normalizedSource.split("\n");
+    const lineBuffers = [];
+    let currentAddress = startAddress;
+    for (const rawLine of lines) {
+        const trimmedRight = rawLine.replace(/\s+$/u, "");
+        if (trimmedRight === "") {
+            continue;
+        }
+        const match = /^\s*(\d+)\s*(.*)$/u.exec(trimmedRight);
+        if (!match) {
+            throw new Error(`Expected line number at: "${rawLine}"`);
+        }
+        const lineNumber = Number.parseInt(match[1], 10);
+        if (!Number.isInteger(lineNumber) || lineNumber < 0 || lineNumber > 65535) {
+            throw new Error(`Line number out of range: ${match[1]}`);
+        }
+        const content = match[2] ?? "";
+        const tokenised = tokenize(content);
+        const lineLength = 2 + 2 + tokenised.length + 1;
+        const nextAddress = currentAddress + lineLength;
+        const lineBuffer = Buffer.alloc(lineLength);
+        lineBuffer.writeUInt16LE(nextAddress, 0);
+        lineBuffer.writeUInt16LE(lineNumber, 2);
+        Buffer.from(tokenised).copy(lineBuffer, 4);
+        lineBuffer[4 + tokenised.length] = 0x00;
+        lineBuffers.push(lineBuffer);
+        currentAddress = nextAddress;
+    }
+    const header = Buffer.alloc(2);
+    header.writeUInt16LE(startAddress, 0);
+    return Buffer.concat([header, ...lineBuffers, Buffer.from([0x00, 0x00])]);
+}
+function normalize(input) {
+    const unified = input.replace(/\r\n?/g, "\n");
+    const withoutTrailingNewlines = unified.replace(/\n+$/u, "");
+    return `${withoutTrailingNewlines}\n`;
+}
+function tokenize(content) {
+    const upper = content.toUpperCase();
+    const bytes = [];
+    let index = 0;
+    let inString = false;
+    let inRemark = false;
+    while (index < content.length) {
+        if (!inString && !inRemark) {
+            const token = matchToken(upper, index);
+            if (token) {
+                bytes.push(token.byte);
+                index += token.text.length;
+                if (token.byte === REM_TOKEN) {
+                    inRemark = true;
+                }
+                continue;
+            }
+        }
+        const char = content[index];
+        // Special handling for string literals: encode the inner text in one go
+        if (!inRemark && char === '"') {
+            bytes.push(asciiToPetscii('"'));
+            inString = !inString;
+            index += 1;
+            if (inString) {
+                // capture until next quote or end of line
+                const start = index;
+                let end = start;
+                while (end < content.length && content[end] !== '"') {
+                    end += 1;
+                }
+                const segment = content.slice(start, end);
+                const encoded = encodeStringWithNames(segment);
+                for (const b of encoded)
+                    bytes.push(b);
+                index = end; // leave closing quote to be processed next iteration
+            }
+            continue;
+        }
+        const plainChar = (!inString && !inRemark ? upper[index] : char) ?? char;
+        bytes.push(asciiToPetscii(plainChar));
+        index += 1;
+    }
+    if (bytes.length === 0) {
+        bytes.push(0x20);
+    }
+    return Uint8Array.from(bytes);
+}
+function matchToken(upperSource, startIndex) {
+    for (const entry of TOKEN_TABLE) {
+        if (upperSource.startsWith(entry.text, startIndex)) {
+            return entry;
+        }
+    }
+    return undefined;
+}
+// asciiToPetscii is imported from petscii.ts
+function buildTokenTable() {
+    const baseTokens = [
+        ["END", 0x80],
+        ["FOR", 0x81],
+        ["NEXT", 0x82],
+        ["DATA", 0x83],
+        ["INPUT#", 0x84],
+        ["INPUT", 0x85],
+        ["DIM", 0x86],
+        ["READ", 0x87],
+        ["LET", 0x88],
+        ["GOTO", 0x89],
+        ["RUN", 0x8a],
+        ["IF", 0x8b],
+        ["RESTORE", 0x8c],
+        ["GOSUB", 0x8d],
+        ["RETURN", 0x8e],
+        ["REM", REM_TOKEN],
+        ["STOP", 0x90],
+        ["ON", 0x91],
+        ["WAIT", 0x92],
+        ["LOAD", 0x93],
+        ["SAVE", 0x94],
+        ["VERIFY", 0x95],
+        ["DEF", 0x96],
+        ["POKE", 0x97],
+        ["PRINT#", 0x98],
+        ["PRINT", 0x99],
+        ["CONT", 0x9a],
+        ["LIST", 0x9b],
+        ["CLR", 0x9c],
+        ["CMD", 0x9d],
+        ["SYS", 0x9e],
+        ["OPEN", 0x9f],
+        ["CLOSE", 0xa0],
+        ["GET", 0xa1],
+        ["NEW", 0xa2],
+        ["TAB(", 0xa3],
+        ["TO", 0xa4],
+        ["FN", 0xa5],
+        ["SPC(", 0xa6],
+        ["THEN", 0xa7],
+        ["NOT", 0xa8],
+        ["STEP", 0xa9],
+        ["+", 0xaa],
+        ["-", 0xab],
+        ["*", 0xac],
+        ["/", 0xad],
+        ["^", 0xae],
+        ["AND", 0xaf],
+        ["OR", 0xb0],
+        [">", 0xb1],
+        ["=", 0xb2],
+        ["<", 0xb3],
+        ["SGN", 0xb4],
+        ["INT", 0xb5],
+        ["ABS", 0xb6],
+        ["USR", 0xb7],
+        ["FRE", 0xb8],
+        ["POS", 0xb9],
+        ["SQR", 0xba],
+        ["RND", 0xbb],
+        ["LOG", 0xbc],
+        ["EXP", 0xbd],
+        ["COS", 0xbe],
+        ["SIN", 0xbf],
+        ["TAN", 0xc0],
+        ["ATN", 0xc1],
+        ["PEEK", 0xc2],
+        ["LEN", 0xc3],
+        ["STR$", 0xc4],
+        ["VAL", 0xc5],
+        ["ASC", 0xc6],
+        ["CHR$", 0xc7],
+        ["LEFT$", 0xc8],
+        ["RIGHT$", 0xc9],
+        ["MID$", 0xca],
+        ["GO", 0xcb],
+    ];
+    return baseTokens
+        .slice()
+        .sort((a, b) => b[0].length - a[0].length)
+        .map(([text, byte]) => ({ text, byte }));
+}

package/dist/bootstrap/stdio-logger.js

@@ -0,0 +1,32 @@
+import { Console } from "node:console";
+const METHODS = [
+    "log",
+    "info",
+    "debug",
+    "warn",
+    "error",
+    "dir",
+    "trace",
+    "time",
+    "timeEnd",
+    "timeLog",
+    "table",
+    "group",
+    "groupCollapsed",
+    "groupEnd",
+    "count",
+    "countReset",
+    "assert",
+    "profile",
+    "profileEnd",
+];
+const stderrConsole = new Console({ stdout: process.stderr, stderr: process.stderr });
+const consoleMethods = console;
+for (const method of METHODS) {
+    const implementation = stderrConsole[method];
+    if (typeof implementation === "function") {
+        consoleMethods[method] = (...args) => {
+            return implementation.apply(stderrConsole, args);
+        };
+    }
+}