@oh-my-pi/pi-coding-agent 17.1.0 → 17.1.2

package/src/stt/wav.ts

@@ -1,173 +0,0 @@
-/**
- * Minimal WAV (RIFF/PCM) decoder producing the Float32Array @ 16 kHz mono that
- * transformers.js `automatic-speech-recognition` expects. Ports the decode/
- * mono-mix/resample logic from the retired Python `transcribe.py` (which read
- * via the stdlib `wave` module) so STT no longer shells out to Python.
- *
- * Supported sample formats: PCM uint8 (8-bit), int16 (16-bit), int32 (32-bit),
- * and IEEE float32 (format tag 3). Any number of channels is mixed down to mono.
- */
-
-/** transformers.js Whisper feature extractor operates at 16 kHz. */
-export const TARGET_SAMPLE_RATE = 16_000;
-
-const WAV_FORMAT_PCM = 1;
-const WAV_FORMAT_IEEE_FLOAT = 3;
-const WAV_FORMAT_EXTENSIBLE = 0xfffe;
-
-interface WavData {
-	format: number;
-	channels: number;
-	sampleRate: number;
-	bitsPerSample: number;
-	/** Raw PCM/float bytes from the `data` chunk. */
-	samples: DataView;
-}
-
-function readFourCc(view: DataView, offset: number): string {
-	return String.fromCharCode(
-		view.getUint8(offset),
-		view.getUint8(offset + 1),
-		view.getUint8(offset + 2),
-		view.getUint8(offset + 3),
-	);
-}
-
-/** Parse the RIFF container, returning the `fmt ` parameters and `data` bytes. */
-function parseWav(buffer: ArrayBuffer): WavData {
-	const view = new DataView(buffer);
-	if (buffer.byteLength < 12 || readFourCc(view, 0) !== "RIFF" || readFourCc(view, 8) !== "WAVE") {
-		throw new Error("Not a RIFF/WAVE file");
-	}
-
-	let format: number | undefined;
-	let channels = 0;
-	let sampleRate = 0;
-	let bitsPerSample = 0;
-	let samples: DataView | undefined;
-
-	// Chunks begin after the 12-byte RIFF/WAVE header; each is an 8-byte header
-	// (4-char id + uint32 LE size) followed by `size` bytes padded to even.
-	let offset = 12;
-	while (offset + 8 <= buffer.byteLength) {
-		const id = readFourCc(view, offset);
-		const size = view.getUint32(offset + 4, true);
-		const body = offset + 8;
-		if (id === "fmt ") {
-			format = view.getUint16(body, true);
-			channels = view.getUint16(body + 2, true);
-			sampleRate = view.getUint32(body + 4, true);
-			bitsPerSample = view.getUint16(body + 14, true);
-			// WAVE_FORMAT_EXTENSIBLE (ffmpeg & friends): the real codec is the
-			// first 2 bytes of the SubFormat GUID in the fmt extension.
-			if (format === WAV_FORMAT_EXTENSIBLE && size >= 40) format = view.getUint16(body + 24, true);
-		} else if (id === "data") {
-			const length = Math.min(size, buffer.byteLength - body);
-			samples = new DataView(buffer, body, length);
-		}
-		offset = body + size + (size % 2);
-	}
-
-	if (format === undefined || samples === undefined || channels < 1 || sampleRate < 1) {
-		throw new Error("WAV file missing fmt/data chunks");
-	}
-	return { format, channels, sampleRate, bitsPerSample, samples };
-}
-
-/** Decode raw PCM/float bytes into interleaved normalized [-1, 1] float samples. */
-function decodeSamples(wav: WavData): Float32Array {
-	const { format, bitsPerSample, samples } = wav;
-	const view = samples;
-	if (format === WAV_FORMAT_IEEE_FLOAT && bitsPerSample === 32) {
-		const count = Math.floor(view.byteLength / 4);
-		const out = new Float32Array(count);
-		for (let i = 0; i < count; i += 1) out[i] = view.getFloat32(i * 4, true);
-		return out;
-	}
-	if (format !== WAV_FORMAT_PCM) {
-		throw new Error(`Unsupported WAV format tag: ${format}`);
-	}
-	if (bitsPerSample === 16) {
-		const count = Math.floor(view.byteLength / 2);
-		const out = new Float32Array(count);
-		for (let i = 0; i < count; i += 1) out[i] = view.getInt16(i * 2, true) / 32_768;
-		return out;
-	}
-	if (bitsPerSample === 8) {
-		// 8-bit PCM is unsigned, centered at 128.
-		const count = view.byteLength;
-		const out = new Float32Array(count);
-		for (let i = 0; i < count; i += 1) out[i] = (view.getUint8(i) - 128) / 128;
-		return out;
-	}
-	if (bitsPerSample === 32) {
-		const count = Math.floor(view.byteLength / 4);
-		const out = new Float32Array(count);
-		for (let i = 0; i < count; i += 1) out[i] = view.getInt32(i * 4, true) / 2_147_483_648;
-		return out;
-	}
-	throw new Error(`Unsupported PCM sample width: ${bitsPerSample} bits`);
-}
-
-/** Average interleaved channels down to a single mono track. */
-function mixToMono(interleaved: Float32Array, channels: number): Float32Array {
-	if (channels <= 1) return interleaved;
-	const frames = Math.floor(interleaved.length / channels);
-	const out = new Float32Array(frames);
-	for (let frame = 0; frame < frames; frame += 1) {
-		let sum = 0;
-		for (let channel = 0; channel < channels; channel += 1) sum += interleaved[frame * channels + channel]!;
-		out[frame] = sum / channels;
-	}
-	return out;
-}
-
-/**
- * Resample via linear interpolation, mirroring the Python `np.interp` over
- * `linspace(0, n-1, targetLen)` against `arange(n)`.
- */
-export function resampleLinear(input: Float32Array, fromRate: number, toRate: number): Float32Array {
-	if (fromRate === toRate || input.length === 0) return input;
-	const n = input.length;
-	const targetLen = Math.max(1, Math.floor((n * toRate) / fromRate));
-	const out = new Float32Array(targetLen);
-	if (targetLen === 1) {
-		out[0] = input[0]!;
-		return out;
-	}
-	const step = (n - 1) / (targetLen - 1);
-	for (let i = 0; i < targetLen; i += 1) {
-		const pos = i * step;
-		const lo = Math.floor(pos);
-		const hi = Math.min(lo + 1, n - 1);
-		const frac = pos - lo;
-		out[i] = input[lo]! * (1 - frac) + input[hi]! * frac;
-	}
-	return out;
-}
-
-/**
- * Decode a WAV byte buffer into a 16 kHz mono Float32Array suitable for the
- * transformers.js Whisper pipeline.
- */
-export function decodeWavToMono16k(buffer: ArrayBuffer): Float32Array {
-	const wav = parseWav(buffer);
-	const interleaved = decodeSamples(wav);
-	const mono = mixToMono(interleaved, wav.channels);
-	return resampleLinear(mono, wav.sampleRate, TARGET_SAMPLE_RATE);
-}
-
-/**
- * Decode interleaved little-endian signed 16-bit PCM bytes into normalized
- * [-1, 1] mono float samples. The live recorder streams raw s16le frames from
- * sox/ffmpeg/arecord stdout (no RIFF container), so this is the hot-path
- * counterpart to {@link decodeWavToMono16k}. `bytes` MUST be 2-byte aligned;
- * callers buffer any trailing odd byte across chunk boundaries.
- */
-export function decodePcmS16LE(bytes: Uint8Array): Float32Array {
-	const count = bytes.length >>> 1;
-	const view = new DataView(bytes.buffer, bytes.byteOffset, count * 2);
-	const out = new Float32Array(count);
-	for (let i = 0; i < count; i += 1) out[i] = view.getInt16(i * 2, true) / 32_768;
-	return out;
-}

package/src/tts/player.ts

@@ -1,137 +0,0 @@
-/**
- * Cross-platform audio-file playback via the system's built-in players.
- *
- * The selection logic is split into a pure, injectable builder
- * ({@link playerCommandsFor}) so it can be unit-tested without spawning a
- * process or touching PATH, and a thin runtime wrapper ({@link playAudioFile})
- * that walks the resulting fallback chain.
- */
-import * as fs from "node:fs/promises";
-import { $which } from "@oh-my-pi/pi-utils";
-import { getToolPath } from "../utils/tools-manager";
-
-export interface PlayerCommand {
-	cmd: string;
-	args: string[];
-}
-
-/** Injection seam for {@link playerCommandsFor} — defaults to real PATH/tools lookups. */
-export interface PlayerLookup {
-	which?: (bin: string) => string | null;
-	ffmpeg?: () => string | null;
-}
-
-/**
- * Build the ordered list of playback commands to try for `filePath` on the
- * given platform. Pure + injectable so the selection logic is testable without
- * spawning anything.
- *
- * - darwin: `afplay` (always present on macOS).
- * - win32: PowerShell `Media.SoundPlayer.PlaySync()` (no extra deps).
- * - linux/other POSIX: `paplay` (PulseAudio) → `aplay` (ALSA) → the bundled
- *   static `ffmpeg` (`-f pulse` then `-f alsa`). Empty result means nothing is
- *   available and the caller should surface an install hint.
- */
-export function playerCommandsFor(
-	platform: NodeJS.Platform,
-	filePath: string,
-	lookup: PlayerLookup = {},
-): PlayerCommand[] {
-	const which = lookup.which ?? $which;
-	const ffmpeg = lookup.ffmpeg ?? ((): string | null => getToolPath("ffmpeg"));
-
-	if (platform === "darwin") {
-		return [{ cmd: "afplay", args: [filePath] }];
-	}
-	if (platform === "win32") {
-		return [
-			{
-				cmd: "powershell",
-				args: ["-NoProfile", "-Command", `(New-Object Media.SoundPlayer '${filePath}').PlaySync()`],
-			},
-		];
-	}
-
-	// Linux and other POSIX desktops share the PulseAudio/ALSA fallback chain.
-	const commands: PlayerCommand[] = [];
-	const paplay = which("paplay");
-	if (paplay) commands.push({ cmd: paplay, args: [filePath] });
-	const aplay = which("aplay");
-	if (aplay) commands.push({ cmd: aplay, args: [filePath] });
-	const ffmpegBin = ffmpeg();
-	if (ffmpegBin) {
-		commands.push({
-			cmd: ffmpegBin,
-			args: ["-loglevel", "error", "-nostdin", "-i", filePath, "-f", "pulse", "default"],
-		});
-		commands.push({
-			cmd: ffmpegBin,
-			args: ["-loglevel", "error", "-nostdin", "-i", filePath, "-f", "alsa", "default"],
-		});
-	}
-	return commands;
-}
-
-export interface PlayAudioOptions {
-	signal?: AbortSignal;
-}
-
-function playbackAbortError(signal: AbortSignal): Error {
-	const reason = signal.reason;
-	return reason instanceof Error ? reason : new DOMException("Audio playback aborted", "AbortError");
-}
-
-/**
- * Play `filePath` through the speakers, trying each candidate command in order
- * and returning on the first clean exit. Throws an actionable Error if no
- * player exists or every candidate fails (with the collected stderr).
- */
-export async function playAudioFile(filePath: string, options: PlayAudioOptions = {}): Promise<void> {
-	const { signal } = options;
-	if (signal?.aborted) throw playbackAbortError(signal);
-	const commands = playerCommandsFor(process.platform, filePath);
-	if (commands.length === 0) {
-		throw new Error(
-			"No audio player available. Install PulseAudio (paplay) or ALSA (aplay), " +
-				"or run `omp setup speech` to download a bundled ffmpeg.",
-		);
-	}
-
-	const failures: string[] = [];
-	for (const command of commands) {
-		if (signal?.aborted) throw playbackAbortError(signal);
-		try {
-			const proc = Bun.spawn([command.cmd, ...command.args], { stdout: "ignore", stderr: "pipe" });
-			let killTimer: NodeJS.Timeout | undefined;
-			const abort = (): void => {
-				proc.kill("SIGTERM");
-				killTimer = setTimeout(() => proc.kill("SIGKILL"), 500);
-				killTimer.unref?.();
-			};
-			signal?.addEventListener("abort", abort, { once: true });
-			try {
-				const code = await proc.exited;
-				if (signal?.aborted) throw playbackAbortError(signal);
-				if (code === 0) return;
-				let stderr = "";
-				if (proc.stderr && typeof proc.stderr !== "number") {
-					stderr = await new Response(proc.stderr as ReadableStream).text();
-				}
-				failures.push(`${command.cmd} exited ${code}${stderr.trim() ? `: ${stderr.trim()}` : ""}`);
-			} finally {
-				signal?.removeEventListener("abort", abort);
-				if (killTimer) clearTimeout(killTimer);
-			}
-		} catch (err) {
-			if (signal?.aborted) throw playbackAbortError(signal);
-			failures.push(`${command.cmd}: ${err instanceof Error ? err.message : String(err)}`);
-		}
-	}
-
-	throw new Error(`Audio playback failed:\n${failures.join("\n")}`);
-}
-
-/** Best-effort temp-file cleanup used by callers after playback. */
-export async function removeTempFile(filePath: string): Promise<void> {
-	await fs.unlink(filePath).catch(() => {});
-}