notemap 1.0.0

package/dist/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ui_1 = require("./ui");
+(0, ui_1.startApp)();

package/dist/mapsManager.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapsManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const MAPS_DIR = path.join(os.homedir(), '.config', 'midimapper', 'maps');
+class MapsManager {
+    constructor() {
+        fs.mkdirSync(MAPS_DIR, { recursive: true });
+    }
+    list() {
+        return fs
+            .readdirSync(MAPS_DIR)
+            .filter(f => f.endsWith('.json'))
+            .map(f => f.replace(/\.json$/, ''))
+            .sort();
+    }
+    load(name) {
+        const file = path.join(MAPS_DIR, `${name}.json`);
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    save(map) {
+        const file = path.join(MAPS_DIR, `${map.name}.json`);
+        fs.writeFileSync(file, JSON.stringify(map, null, 2), 'utf-8');
+    }
+    exists(name) {
+        return fs.existsSync(path.join(MAPS_DIR, `${name}.json`));
+    }
+    get mapsDir() {
+        return MAPS_DIR;
+    }
+}
+exports.MapsManager = MapsManager;

package/dist/midiEngine.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MidiEngine = void 0;
+const midi_1 = require("midi");
+class MidiEngine {
+    constructor() {
+        this.input = null;
+        this.output = null;
+    }
+    getInputDevices() {
+        const tmp = new midi_1.Input();
+        const count = tmp.getPortCount();
+        const names = [];
+        for (let i = 0; i < count; i++) {
+            names.push(tmp.getPortName(i));
+        }
+        return names;
+    }
+    /** Open a device port and forward note-on events to the callback. */
+    startMapping(deviceIndex, onNoteOn) {
+        this.close();
+        this.input = new midi_1.Input();
+        this.input.ignoreTypes(false, false, true);
+        this.input.openPort(deviceIndex);
+        this.input.on('message', (_dt, message) => {
+            const [status, note, velocity] = message;
+            if ((status & 0xf0) === 0x90 && velocity > 0) {
+                onNoteOn(note);
+            }
+        });
+    }
+    /**
+     * Open the device and a virtual output port named "MidiMapper".
+     * All messages are forwarded; note on/off events have their note
+     * numbers remapped according to the provided mappings.
+     */
+    startActive(deviceIndex, mappings, onMapped) {
+        this.close();
+        const noteMap = new Map(mappings.map(m => [m.from, m.to]));
+        this.output = new midi_1.Output();
+        this.output.openVirtualPort('MidiMapper');
+        this.input = new midi_1.Input();
+        this.input.ignoreTypes(false, false, true);
+        this.input.openPort(deviceIndex);
+        this.input.on('message', (_dt, message) => {
+            if (!this.output)
+                return;
+            const [status, data1, data2] = message;
+            const type = status & 0xf0;
+            if (type === 0x90 || type === 0x80) {
+                const mapped = noteMap.get(data1) ?? data1;
+                const channel = status & 0x0f;
+                const isNoteOn = type === 0x90 && data2 > 0;
+                this.output.sendMessage([(type | channel), mapped, data2]);
+                if (isNoteOn && noteMap.has(data1) && onMapped) {
+                    onMapped(data1, mapped);
+                }
+            }
+            else {
+                this.output.sendMessage(message);
+            }
+        });
+    }
+    close() {
+        if (this.input) {
+            try {
+                this.input.removeAllListeners('message');
+                this.input.closePort();
+            }
+            catch {
+                // ignore
+            }
+            this.input = null;
+        }
+        if (this.output) {
+            try {
+                this.output.closePort();
+            }
+            catch {
+                // ignore
+            }
+            this.output = null;
+        }
+    }
+}
+exports.MidiEngine = MidiEngine;

package/dist/notes.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noteName = noteName;
+exports.noteLabel = noteLabel;
+const NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+function noteName(n) {
+    const octave = Math.floor(n / 12) - 1;
+    return `${NOTE_NAMES[n % 12]}${octave}`;
+}
+function noteLabel(n) {
+    return `${noteName(n)} (${n})`;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui.js

@@ -0,0 +1,474 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startApp = startApp;
+const blessed = __importStar(require("blessed"));
+const midiEngine_1 = require("./midiEngine");
+const mapsManager_1 = require("./mapsManager");
+const notes_1 = require("./notes");
+function startApp() {
+    const screen = blessed.screen({
+        smartCSR: true,
+        title: 'MidiMapper',
+        fullUnicode: true,
+        forceUnicode: true,
+    });
+    const engine = new midiEngine_1.MidiEngine();
+    const maps = new mapsManager_1.MapsManager();
+    // ── App state ────────────────────────────────────────────────────────
+    let state = 'DEVICE_SELECT';
+    let selectedDevice = -1;
+    let selectedDeviceName = '';
+    let pendingMappings = [];
+    let awaitingFirst = true;
+    let firstNote = null;
+    let activeMapName = '';
+    // ── Persistent chrome ────────────────────────────────────────────────
+    const header = blessed.box({
+        parent: screen,
+        top: 0,
+        left: 0,
+        width: '100%',
+        height: 3,
+        tags: true,
+        content: '  {bold}MidiMapper{/bold}',
+        style: { fg: 'white', bg: 'blue', bold: true },
+        border: { type: 'line' },
+    });
+    // suppress unused warning
+    void header;
+    const footer = blessed.box({
+        parent: screen,
+        bottom: 0,
+        left: 0,
+        width: '100%',
+        height: 3,
+        tags: true,
+        style: { fg: 'white', bg: '#111111' },
+        border: { type: 'line' },
+    });
+    function setFooter(text) {
+        footer.setContent(`  ${text}`);
+        screen.render();
+    }
+    // ── Content area helpers ─────────────────────────────────────────────
+    let content = null;
+    function clearContent() {
+        if (content) {
+            content.destroy();
+            content = null;
+        }
+    }
+    function makeContentBox(label, borderColor) {
+        clearContent();
+        const box = blessed.box({
+            parent: screen,
+            top: 3,
+            left: 0,
+            width: '100%',
+            height: '100%-6',
+            label: `  ${label}  `,
+            tags: true,
+            border: { type: 'line' },
+            style: {
+                border: { fg: borderColor },
+                label: { fg: borderColor, bold: true },
+            },
+        });
+        content = box;
+        return box;
+    }
+    // ── Global key handlers (state-aware) ────────────────────────────────
+    screen.key(['q', 'C-c'], () => {
+        engine.close();
+        screen.destroy();
+        process.exit(0);
+    });
+    screen.key('enter', () => {
+        if (state === 'MAPPING_MODE')
+            finishMapping();
+    });
+    screen.key('escape', () => {
+        if (state === 'MAP_SELECT') {
+            engine.close();
+            showDeviceSelect();
+        }
+        else if (state === 'MAPPING_MODE') {
+            engine.close();
+            showMapSelect();
+        }
+    });
+    screen.key('r', () => {
+        if (state === 'ACTIVE') {
+            engine.close();
+            showMapSelect();
+        }
+    });
+    screen.key('d', () => {
+        if (state === 'ACTIVE') {
+            engine.close();
+            showDeviceSelect();
+        }
+    });
+    // ── Device Select ────────────────────────────────────────────────────
+    function showDeviceSelect() {
+        state = 'DEVICE_SELECT';
+        const devices = engine.getInputDevices();
+        if (devices.length === 0) {
+            const box = makeContentBox('Select MIDI Input Device', 'cyan');
+            box.setContent('\n\n  {red-fg}No MIDI input devices found.{/red-fg}\n\n' +
+                '  Make sure a MIDI device is connected, then press {bold}r{/bold} to refresh.');
+            setFooter('r: Refresh  |  q / Ctrl+C: Quit');
+            screen.key('r', showDeviceSelect);
+            screen.render();
+            return;
+        }
+        const list = blessed.list({
+            parent: screen,
+            top: 3,
+            left: 0,
+            width: '100%',
+            height: '100%-6',
+            label: '  Select MIDI Input Device  ',
+            tags: true,
+            keys: true,
+            vi: true,
+            mouse: true,
+            border: { type: 'line' },
+            style: {
+                border: { fg: 'cyan' },
+                selected: { bg: 'blue', fg: 'white', bold: true },
+                item: { fg: 'white' },
+            },
+            items: devices.map((d, i) => `  [${i}]  ${d}`),
+        });
+        content = list;
+        list.select(0);
+        list.focus();
+        setFooter('\u2191\u2193: Navigate  |  Enter: Select  |  q: Quit');
+        list.on('select', (_item, index) => {
+            selectedDevice = index;
+            selectedDeviceName = devices[index];
+            showMapSelect();
+        });
+        screen.render();
+    }
+    // ── Map Select ───────────────────────────────────────────────────────
+    function showMapSelect() {
+        state = 'MAP_SELECT';
+        engine.close();
+        const mapNames = maps.list();
+        const items = [
+            '  {green-fg}+ Create New Map{/green-fg}',
+            ...mapNames.map(n => `    ${n}`),
+        ];
+        const list = blessed.list({
+            parent: screen,
+            top: 3,
+            left: 0,
+            width: '100%',
+            height: '100%-6',
+            label: `  Select Map  \u2014  Input: {cyan-fg}${selectedDeviceName}{/cyan-fg}  `,
+            tags: true,
+            keys: true,
+            vi: true,
+            mouse: true,
+            border: { type: 'line' },
+            style: {
+                border: { fg: 'cyan' },
+                selected: { bg: 'blue', fg: 'white', bold: true },
+                item: { fg: 'white' },
+            },
+            items,
+        });
+        content = list;
+        list.select(0);
+        list.focus();
+        setFooter('\u2191\u2193: Navigate  |  Enter: Select  |  Esc: Back  |  q: Quit');
+        list.on('select', (_item, index) => {
+            if (index === 0) {
+                startMappingMode();
+            }
+            else {
+                const name = mapNames[index - 1];
+                const map = maps.load(name);
+                startActive(map.name, map.mappings);
+            }
+        });
+        screen.render();
+    }
+    // ── Mapping Mode ─────────────────────────────────────────────────────
+    function startMappingMode() {
+        pendingMappings = [];
+        awaitingFirst = true;
+        firstNote = null;
+        showMappingMode();
+    }
+    // Holds refs so we can update them from MIDI callbacks
+    let mappingListEl = null;
+    let mappingStatusEl = null;
+    function updateMappingDisplay() {
+        if (!mappingListEl || !mappingStatusEl)
+            return;
+        if (pendingMappings.length === 0) {
+            mappingListEl.setContent('  {gray-fg}(no mappings yet){/gray-fg}');
+        }
+        else {
+            const lines = pendingMappings.map(m => `  {cyan-fg}${(0, notes_1.noteLabel)(m.from)}{/cyan-fg}  \u2192  {green-fg}${(0, notes_1.noteLabel)(m.to)}{/green-fg}`);
+            mappingListEl.setContent(lines.join('\n'));
+        }
+        if (awaitingFirst) {
+            const count = pendingMappings.length;
+            mappingStatusEl.setContent(`{yellow-fg}\u25cf Press a key on your MIDI device to set the {bold}source{/bold} note...{/yellow-fg}` +
+                (count > 0
+                    ? `  {gray-fg}(${count} mapping${count !== 1 ? 's' : ''} so far){/gray-fg}`
+                    : ''));
+        }
+        else {
+            mappingStatusEl.setContent(`{yellow-fg}Source: {bold}${(0, notes_1.noteLabel)(firstNote)}{/bold}  \u2014  Now press the {bold}destination{/bold} key...{/yellow-fg}`);
+        }
+        screen.render();
+    }
+    function showMappingMode() {
+        state = 'MAPPING_MODE';
+        const box = makeContentBox('Create New Map', 'cyan');
+        // Instructions at top
+        blessed.box({
+            parent: box,
+            top: 1,
+            left: 2,
+            width: '100%-4',
+            height: 2,
+            tags: true,
+            content: '  Press a key on your MIDI device to begin mapping.\n' +
+                '  Each pair of key presses creates one mapping: {cyan-fg}source{/cyan-fg} \u2192 {green-fg}destination{/green-fg}.',
+        });
+        // Divider
+        blessed.line({
+            parent: box,
+            top: 3,
+            left: 1,
+            width: '100%-2',
+            orientation: 'horizontal',
+            style: { fg: '#444444' },
+        });
+        // Mappings list (scrollable)
+        mappingListEl = blessed.box({
+            parent: box,
+            top: 4,
+            left: 2,
+            width: '100%-4',
+            height: '100%-10',
+            scrollable: true,
+            alwaysScroll: true,
+            tags: true,
+        });
+        // Status line near bottom
+        mappingStatusEl = blessed.box({
+            parent: box,
+            bottom: 2,
+            left: 2,
+            width: '100%-4',
+            height: 1,
+            tags: true,
+        });
+        updateMappingDisplay();
+        setFooter('MIDI keys: Map notes  |  Enter: Done  |  Esc: Cancel  |  q: Quit');
+        engine.startMapping(selectedDevice, (note) => {
+            if (awaitingFirst) {
+                firstNote = note;
+                awaitingFirst = false;
+            }
+            else {
+                if (firstNote !== null) {
+                    pendingMappings.push({ from: firstNote, to: note });
+                    firstNote = null;
+                    awaitingFirst = true;
+                }
+            }
+            updateMappingDisplay();
+        });
+        screen.render();
+    }
+    function finishMapping() {
+        if (!awaitingFirst) {
+            // incomplete pair — warn
+            if (mappingStatusEl) {
+                mappingStatusEl.setContent('{red-fg}Incomplete pair — press the destination key first, then Enter.{/red-fg}');
+                screen.render();
+            }
+            return;
+        }
+        if (pendingMappings.length === 0) {
+            if (mappingStatusEl) {
+                mappingStatusEl.setContent('{red-fg}No mappings yet — press some keys to create mappings first.{/red-fg}');
+                screen.render();
+            }
+            return;
+        }
+        engine.close();
+        showNameInput();
+    }
+    // ── Name Input ───────────────────────────────────────────────────────
+    function showNameInput() {
+        state = 'NAME_INPUT';
+        const box = makeContentBox('Save Map', 'cyan');
+        blessed.box({
+            parent: box,
+            top: 2,
+            left: 4,
+            width: '100%-8',
+            height: 3,
+            tags: true,
+            content: `  {bold}${pendingMappings.length}{/bold} mapping${pendingMappings.length !== 1 ? 's' : ''} ready to save.\n\n` +
+                '  Enter a name for this map:',
+        });
+        const inputBox = blessed.textbox({
+            parent: box,
+            top: 6,
+            left: 4,
+            width: 42,
+            height: 3,
+            inputOnFocus: true,
+            keys: true,
+            mouse: true,
+            border: { type: 'line' },
+            style: {
+                border: { fg: 'yellow' },
+                focus: { border: { fg: 'green' } },
+                fg: 'white',
+            },
+        });
+        const errorEl = blessed.box({
+            parent: box,
+            top: 10,
+            left: 4,
+            width: '100%-8',
+            height: 1,
+            tags: true,
+        });
+        inputBox.focus();
+        setFooter('Type a name  |  Enter: Save  |  Esc: Back to mapping  |  q: Quit');
+        inputBox.on('submit', (value) => {
+            const raw = (value ?? inputBox.getValue()).trim();
+            const name = raw.replace(/[^a-zA-Z0-9_-]/g, '_');
+            if (!name) {
+                errorEl.setContent('{red-fg}Please enter a name.{/red-fg}');
+                inputBox.clearValue();
+                inputBox.focus();
+                screen.render();
+                return;
+            }
+            if (maps.exists(name)) {
+                errorEl.setContent(`{yellow-fg}A map named "{bold}${name}{/bold}" already exists \u2014 it will be overwritten.{/yellow-fg}  Saving...`);
+                screen.render();
+            }
+            maps.save({ name, mappings: pendingMappings });
+            startActive(name, pendingMappings);
+        });
+        inputBox.on('cancel', () => {
+            // Escape — go back to mapping mode with existing mappings preserved
+            showMappingMode();
+        });
+        screen.render();
+    }
+    // ── Active ───────────────────────────────────────────────────────────
+    function startActive(mapName, mappings) {
+        state = 'ACTIVE';
+        activeMapName = mapName;
+        const box = makeContentBox('MidiMapper \u2014 Running', 'green');
+        const infoEl = blessed.box({
+            parent: box,
+            top: 1,
+            left: 3,
+            width: '100%-6',
+            height: 6,
+            tags: true,
+        });
+        const mapEl = blessed.box({
+            parent: box,
+            top: 7,
+            left: 3,
+            width: '100%-6',
+            height: '100%-16',
+            scrollable: true,
+            alwaysScroll: true,
+            tags: true,
+        });
+        const lastEl = blessed.box({
+            parent: box,
+            bottom: 1,
+            left: 3,
+            width: '100%-6',
+            height: 2,
+            tags: true,
+        });
+        function renderInfo() {
+            infoEl.setContent(`  {bold}Input device:{/bold}  {cyan-fg}${selectedDeviceName}{/cyan-fg}\n` +
+                `  {bold}Map:{/bold}           {cyan-fg}${mapName}{/cyan-fg}\n` +
+                `  {bold}Virtual output:{/bold} {cyan-fg}MidiMapper{/cyan-fg}  {gray-fg}(connect this in your DAW){/gray-fg}\n` +
+                `  {bold}Mappings:{/bold}      {white-fg}${mappings.length}{/white-fg}`);
+        }
+        function renderMappings() {
+            if (mappings.length === 0) {
+                mapEl.setContent('  {gray-fg}(identity — all notes pass through unchanged){/gray-fg}');
+                return;
+            }
+            mapEl.setContent(mappings
+                .map(m => `  {cyan-fg}${(0, notes_1.noteLabel)(m.from)}{/cyan-fg}  \u2192  {green-fg}${(0, notes_1.noteLabel)(m.to)}{/green-fg}`)
+                .join('\n'));
+        }
+        function renderLast(from, to) {
+            if (from === undefined || to === undefined) {
+                lastEl.setContent('  {gray-fg}Last mapped note: \u2014{/gray-fg}');
+            }
+            else {
+                lastEl.setContent(`  {bold}Last:{/bold}  {cyan-fg}${(0, notes_1.noteLabel)(from)}{/cyan-fg}  \u2192  {green-fg}${(0, notes_1.noteLabel)(to)}{/green-fg}`);
+            }
+        }
+        renderInfo();
+        renderMappings();
+        renderLast();
+        engine.startActive(selectedDevice, mappings, (from, to) => {
+            renderLast(from, to);
+            screen.render();
+        });
+        setFooter(`r: Change map  |  d: Change device  |  q: Quit` +
+            `  {gray-fg}[map: ${activeMapName}]{/gray-fg}`);
+        screen.render();
+    }
+    // ── Start ────────────────────────────────────────────────────────────
+    showDeviceSelect();
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "notemap",
+  "version": "1.0.0",
+  "description": "MIDI note mapper with terminal UI",
+  "main": "dist/index.js",
+  "bin": {
+    "notemap": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/samdesota/notemap.git"
+  },
+  "scripts": {
+    "dev": "ts-node src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "blessed": "^0.1.81",
+    "midi": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/blessed": "^0.1.25",
+    "@types/midi": "^2.0.0",
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.3.0"
+  }
+}