@lumiastream/wakeword 1.0.1-alpha.11 → 1.0.1-alpha.2

package/bin/wakeword

@@ -24,7 +24,7 @@ const child = spawn(
 			path.dirname(fileURLToPath(import.meta.url)),
 			"..",
 			"lib",
-			"voice.js"
+			"voice.mjs"
 		),
 		soxPath,
 		...process.argv.slice(2),

package/lib/voice.mjs

@@ -0,0 +1,97 @@
+import { Model, Recognizer, setLogLevel } from "vosk";
+import record from "@lumiastream/record";
+import { join } from "node:path";
+
+const binPath = join(
+	"binaries",
+	process.platform === "win32"
+		? "sox.exe"
+		: process.platform === "darwin"
+		? "soxmac"
+		: "soxlinux"
+);
+
+console.log(binPath);
+
+let COMMANDS = [
+	"[unk]", // always keep an [unk] fallback!
+];
+
+const SAMPLE_RATE = 16_000;
+setLogLevel(0);
+
+// 1. load model once
+const model = new Model("./models/vosk-model-small-en-us-0.15");
+
+// 2. build a grammar recognizer
+let rec = new Recognizer({
+	model,
+	sampleRate: SAMPLE_RATE,
+	grammar: COMMANDS,
+});
+
+// 3. open the mic (16-kHz, 16-bit, mono)
+const mic = record
+	.record({
+		sampleRate: SAMPLE_RATE,
+		threshold: 0,
+		binPath,
+	})
+	.stream();
+
+mic.on("data", (buf) => {
+	// accept 0.1-sec chunks for low latency
+	if (rec.acceptWaveform(buf)) {
+		const result = rec.result();
+		handle(result?.text?.trim());
+	} else {
+		// optional: JSON.parse(rec.partialResult()).partial for live captions
+	}
+});
+
+// 4. map recognised phrase ➜ action
+function handle(phrase) {
+	// Igonre unk
+	if (phrase.includes("[unk]")) return;
+	if (phrase && COMMANDS.includes(phrase)) {
+		// Send to stdout
+		process.stdout.write(`voice|${phrase}\n`);
+	}
+}
+
+const updateGrammar = (grammar) => {
+	COMMANDS = [...grammar, "[unk]"];
+	rec = new Recognizer({
+		model,
+		sampleRate: SAMPLE_RATE,
+		grammar: COMMANDS,
+	});
+};
+// Listen for CLI input to update grammar at runtime
+import readline from "node:readline";
+
+// Set up readline interface for stdin
+const rl = readline.createInterface({
+	input: process.stdin,
+	output: process.stdout,
+	terminal: false,
+});
+
+// Listen for lines from stdin
+rl.on("line", (line) => {
+	const trimmed = line.trim();
+	// Example: update,open settings,mute audio,start recording
+	if (trimmed.startsWith("update")) {
+		const parts = trimmed.split(",");
+		if (parts.length > 1) {
+			// Remove the "update" command and use the rest as grammar
+			const newGrammar = parts
+				.slice(1)
+				.map((s) => s.trim())
+				.filter(Boolean);
+			if (newGrammar.length > 0) {
+				updateGrammar(newGrammar);
+			}
+		}
+	}
+});

package/package.json

@@ -1,21 +1,27 @@
 {
 	"name": "@lumiastream/wakeword",
-	"version": "1.0.1-alpha.11",
+	"version": "1.0.1-alpha.2",
 	"type": "module",
-	"main": "lib/voice.js",
+	"main": "lib/voice.mjs",
 	"bin": {
 		"wakeword": "bin/wakeword"
 	},
 	"files": [
 		"bin/",
 		"lib/",
-		"models/",
-		"binaries/"
+		"binaries/",
+		"models/"
 	],
 	"scripts": {
-		"postinstall": "chmod +x binaries/soxmac binaries/soxlinux binaries/sox.exe || true"
+		"postinstall": "chmod +x binaries/soxmac binaries/soxlinux || true"
+	},
+	"optionalDependencies": {
+		"@lumiastream/wakeword-darwin": "file:./binaries/soxmac",
+		"@lumiastream/wakeword-linux": "file:./binaries/soxlinux",
+		"@lumiastream/wakeword-win32": "file:./binaries/sox.exe"
 	},
 	"dependencies": {
-		"vosk-koffi": "^1.1.1"
+		"@lumiastream/record": "^1.0.1",
+		"vosk": "^0.3.39"
 	}
 }

package/lib/record.js

@@ -1,119 +0,0 @@
-"use strict";
-
-import assert from "assert";
-import debug from "debug";
-import { spawn } from "child_process";
-import recorders from "./recorders/index.js";
-
-class Recording {
-	constructor(options = {}) {
-		const defaults = {
-			sampleRate: 16000,
-			channels: 1,
-			compress: false,
-			threshold: 0.5,
-			thresholdStart: null,
-			thresholdEnd: null,
-			silence: "1.0",
-			recorder: "sox",
-			endOnSilence: false,
-			audioType: "wav",
-			binPath: null,
-			bufferSize: null,
-			arguments: [],
-		};
-
-		this.options = Object.assign(defaults, options);
-
-		const recorder = recorders.load(this.options.recorder);
-		const { cmd, args, spawnOptions = {} } = recorder(this.options);
-
-		this.cmd = cmd;
-		this.args = args;
-		this.cmdOptions = Object.assign(
-			{ encoding: "binary", stdio: "pipe" },
-			spawnOptions
-		);
-
-		debug(`Started recording`);
-		debug(this.options);
-
-		const command = ` ${this.cmd} ${this.args.join(" ")}`;
-		debug(command);
-
-		return this.start();
-	}
-
-	start() {
-		const { cmd, args, cmdOptions } = this;
-
-		const cp = spawn(cmd, args, cmdOptions);
-		const rec = cp.stdout;
-		const err = cp.stderr;
-
-		this.process = cp; // expose child process
-		this._stream = rec; // expose output stream
-
-		cp.on("close", (code) => {
-			if (code === 0) return;
-			rec.emit(
-				"error",
-				`${this.cmd} has exited with error code ${code}.
-
-Enable debugging with the environment variable DEBUG=record.`
-			);
-		});
-
-		err.on("data", (chunk) => {
-			debug(`STDERR: ${chunk}`);
-		});
-
-		rec.on("data", (chunk) => {
-			debug(`Recording ${chunk.length} bytes`);
-		});
-
-		rec.on("end", () => {
-			debug("Recording ended");
-		});
-
-		return this;
-	}
-
-	stop() {
-		assert(this.process, "Recording not yet started");
-
-		this.process.kill();
-	}
-
-	pause() {
-		assert(this.process, "Recording not yet started");
-
-		this.process.kill("SIGSTOP");
-		this._stream.pause();
-		debug("Paused recording");
-	}
-
-	resume() {
-		assert(this.process, "Recording not yet started");
-
-		this.process.kill("SIGCONT");
-		this._stream.resume();
-		debug("Resumed recording");
-	}
-
-	isPaused() {
-		assert(this.process, "Recording not yet started");
-
-		return this._stream.isPaused();
-	}
-
-	stream() {
-		assert(this._stream, "Recording not yet started");
-
-		return this._stream;
-	}
-}
-
-export default {
-	record: (...args) => new Recording(...args),
-};

package/lib/recorders/arecord.js

@@ -1,27 +0,0 @@
-// On some systems (RasPi), arecord is the prefered recording binary
-export default (options) => {
-	let cmd = "arecord";
-
-	if (options.binPath) {
-		cmd = options.binPath;
-	}
-
-	const args = [
-		"-q", // show no progress
-		"-r",
-		options.sampleRate, // sample rate
-		"-c",
-		options.channels, // channels
-		"-t",
-		options.audioType, // audio type
-		"-f",
-		"S16_LE", // Sample format
-		"-", // pipe
-	];
-
-	if (options.device) {
-		args.unshift("-D", options.device);
-	}
-
-	return { cmd, args };
-};

package/lib/recorders/index.js

@@ -1,23 +0,0 @@
-// import { fileURLToPath } from "node:url";
-// import path from "node:path";
-// const __dirname = path.dirname(fileURLToPath(import.meta.url));
-import rec from "./sox.js";
-
-function load(recorderName) {
-	try {
-		// const recoderPath = path.resolve(__dirname, recorderName);
-		// const module = await import(recoderPath);
-		// return module.default;
-		return rec;
-	} catch (err) {
-		if (err.code === "MODULE_NOT_FOUND") {
-			throw new Error(`No such recorder found: ${recorderName}`);
-		}
-
-		throw err;
-	}
-}
-
-export default {
-	load,
-};

package/lib/recorders/rec.js

@@ -1,36 +0,0 @@
-export default (options) => {
-	let cmd = "rec";
-
-	if (options.binPath) {
-		cmd = options.binPath;
-	}
-
-	let args = [
-		"-q", // show no progress
-		"-r",
-		options.sampleRate, // sample rate
-		"-c",
-		options.channels, // channels
-		"-e",
-		"signed-integer", // sample encoding
-		"-b",
-		"16", // precision (bits)
-		"-t",
-		options.audioType, // audio type
-		"-", // pipe
-	];
-
-	if (options.endOnSilence) {
-		args = args.concat([
-			"silence",
-			"1",
-			"0.1",
-			options.thresholdStart || options.threshold + "%",
-			"1",
-			options.silence,
-			options.thresholdEnd || options.threshold + "%",
-		]);
-	}
-
-	return { cmd, args };
-};

package/lib/recorders/sox.js

@@ -1,51 +0,0 @@
-export default (options) => {
-	let cmd = "sox";
-
-	if (options.binPath) {
-		cmd = options.binPath;
-	}
-
-	let args = [
-		"--default-device",
-		"--no-show-progress", // show no progress
-		"--rate",
-		options.sampleRate, // sample rate
-		"--channels",
-		options.channels, // channels
-		"--encoding",
-		"signed-integer", // sample encoding
-		"--bits",
-		"16", // precision (bits)
-		"--type",
-		options.audioType, // audio type
-		"-", // pipe
-	];
-
-	if (options.bufferSize) {
-		args.push("--buffer", options.bufferSize);
-	}
-
-	if (options.endOnSilence) {
-		args = args.concat([
-			"silence",
-			"1",
-			"0.1",
-			options.thresholdStart || options.threshold + "%",
-			"1",
-			options.silence,
-			options.thresholdEnd || options.threshold + "%",
-		]);
-	}
-
-	if (options.arguments) {
-		args = args.concat(options.arguments);
-	}
-
-	const spawnOptions = {};
-
-	if (options.device) {
-		spawnOptions.env = { ...process.env, AUDIODEV: options.device };
-	}
-
-	return { cmd, args, spawnOptions };
-};

package/lib/voice.js

@@ -1,100 +0,0 @@
-// voice.js  (ESM)
-import { Model, Recognizer, setLogLevel } from "vosk-koffi";
-import record from "./record.js";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { existsSync, chmodSync } from "node:fs";
-import readline from "node:readline";
-
-/* ------------------------------------------------------------------ */
-/* 0. Helpers                                                         */
-/* ------------------------------------------------------------------ */
-const here = dirname(fileURLToPath(import.meta.url));
-
-function unpacked(p) {
-	return p.includes("app.asar")
-		? p.replace("app.asar", "app.asar.unpacked")
-		: p;
-}
-
-/* ------------------------------------------------------------------ */
-/* 1. Resolve SoX binary                                              */
-/* ------------------------------------------------------------------ */
-const exeName = { win32: "sox.exe", darwin: "soxmac", linux: "soxlinux" }[
-	process.platform
-];
-
-/* Priority: argv[2]  → fallback to sibling binaries/<exe> */
-let soxPath = process.argv[2] || join(here, "..", "binaries", exeName);
-soxPath = unpacked(soxPath);
-
-if (!existsSync(soxPath)) throw new Error(`SoX not found: ${soxPath}`);
-try {
-	chmodSync(soxPath, 0o755);
-} catch {
-	/* ignore on read‐only FS */
-}
-
-/* ------------------------------------------------------------------ */
-/* 2. Resolve Vosk model                                              */
-/* ------------------------------------------------------------------ */
-let modelPath = join(here, "..", "models", "vosk-model-small-en-us-0.15");
-modelPath = unpacked(modelPath);
-
-if (!existsSync(modelPath))
-	throw new Error(`Vosk model not found: ${modelPath}`);
-
-/* ------------------------------------------------------------------ */
-/* 3. Initialise recogniser                                           */
-/* ------------------------------------------------------------------ */
-setLogLevel(0);
-
-const SAMPLE_RATE = 16_000;
-let GRAMMAR = ["blue", "[unk]"]; // seed; always keep [unk]
-
-const model = new Model(modelPath);
-let rec = new Recognizer({ model, sampleRate: SAMPLE_RATE, grammar: GRAMMAR });
-
-/* ------------------------------------------------------------------ */
-/* 4. Start the microphone                                            */
-/* ------------------------------------------------------------------ */
-const mic = record
-	.record({ sampleRate: SAMPLE_RATE, threshold: 0, binPath: soxPath })
-	.stream();
-
-mic.on("data", (buf) => {
-	if (rec.acceptWaveform(buf)) {
-		const { text } = rec.result();
-		handle(text.trim());
-	}
-});
-
-/* ------------------------------------------------------------------ */
-/* 5. Handle recognised commands                                      */
-/* ------------------------------------------------------------------ */
-function handle(word) {
-	if (!word || word.includes("[unk]")) return;
-	if (GRAMMAR.includes(word)) process.stdout.write(`voice|${word}\n`);
-}
-
-/* ------------------------------------------------------------------ */
-/* 6. Hot-reload grammar via stdin                                    */
-/* ------------------------------------------------------------------ */
-const rl = readline.createInterface({ input: process.stdin, terminal: false });
-
-rl.on("line", (line) => {
-	const trimmed = line.trim();
-	if (!trimmed.startsWith("update,")) return;
-
-	const phrases = trimmed
-		.split(",")
-		.slice(1)
-		.map((s) => s.trim())
-		.filter(Boolean);
-
-	if (!phrases.length) return;
-
-	GRAMMAR = [...phrases, "[unk]"];
-	rec = new Recognizer({ model, sampleRate: SAMPLE_RATE, grammar: GRAMMAR });
-	console.error("[wakeword] grammar updated →", GRAMMAR.join(", "));
-});