@huozhi/tune 0.1.0

package/README.md

@@ -0,0 +1,27 @@
+# tune
+
+Generate short, random, procedural background music locally from the terminal. No prompts, API keys, model downloads, or audio library are required.
+
+## Quick start
+
+```bash
+npx @huozhi/tune --duration 10 --style chill --output music.wav
+```
+
+With Bun:
+
+```bash
+bunx @huozhi/tune --duration 10 --style upbeat --output music.wav
+```
+
+## Usage
+
+```bash
+bun run generate --duration 10 --output music.wav
+bun run generate --duration 10 --style upbeat --output upbeat.wav
+bun run generate --duration 12 --video input.mp4 --output output.mp4
+```
+
+Styles are `chill`, `upbeat`, `cinematic`, `lofi`, and `playful`. Use `--seed 123` to reproduce the same track. The video mode requires FFmpeg; audio-only mode does not.
+
+See [examples/](examples/) for a generated sample and more commands.

package/dist/cli.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import { unlink, writeFile } from "fs/promises";
+import { spawn } from "child_process";
+var STYLES = {
+  chill: { bpm: [68, 82], chord: [0, 3, 7, 10], pad: 0.07, bass: 0.09, melody: 0.045, percussion: 0.55, melodyDensity: 0.55 },
+  upbeat: { bpm: [112, 132], chord: [0, 4, 7, 11], pad: 0.045, bass: 0.14, melody: 0.065, percussion: 1, melodyDensity: 1 },
+  cinematic: { bpm: [seventy(), 88], chord: [0, 5, 7, 12], pad: 0.1, bass: 0.12, melody: 0.04, percussion: 0.35, melodyDensity: 0.38 },
+  lofi: { bpm: [72, 88], chord: [0, 3, 7, 10], pad: 0.06, bass: 0.13, melody: 0.05, percussion: 0.7, melodyDensity: 0.65 },
+  playful: { bpm: [96, 118], chord: [0, 4, 7, 9], pad: 0.04, bass: 0.11, melody: 0.08, percussion: 0.85, melodyDensity: 1 }
+};
+function seventy() {
+  return 70;
+}
+var SAMPLE_RATE = 44100;
+var TAU = Math.PI * 2;
+function usage() {
+  console.log(`tune \u2014 random procedural background music
+
+Usage:
+  bun run generate --duration 10 --output music.wav
+  bun run generate --duration 12 --video input.mp4 --output output.mp4
+
+Options:
+  --duration, -d  Length in seconds (default: 10)
+  --output, -o    Output WAV, or MP4 when --video is used
+  --video, -v     Existing video to attach the generated music to
+  --seed, -s      Repeatable random seed (optional)
+  --style         chill, upbeat, cinematic, lofi, or playful (default: chill)
+  --help, -h      Show this help
+`);
+  process.exit(0);
+}
+function parseArgs(args) {
+  let duration = 10;
+  let output = "music.wav";
+  let video;
+  let seed = Math.floor(Math.random() * 2 ** 31);
+  let style = "chill";
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h")
+      usage();
+    const next = args[++i];
+    if (arg === "--duration" || arg === "-d")
+      duration = Number(next);
+    else if (arg === "--output" || arg === "-o")
+      output = next;
+    else if (arg === "--video" || arg === "-v")
+      video = next;
+    else if (arg === "--seed" || arg === "-s")
+      seed = Number(next);
+    else if (arg === "--style")
+      style = next;
+    else
+      throw new Error(`Unknown option: ${arg}`);
+  }
+  if (!Number.isFinite(duration) || duration <= 0 || duration > 300) {
+    throw new Error("Duration must be between 0 and 300 seconds.");
+  }
+  if (!output)
+    throw new Error("An output path is required.");
+  if (!(style in STYLES))
+    throw new Error(`Unknown style: ${style}. Choose: ${Object.keys(STYLES).join(", ")}`);
+  return { duration, output, video, seed: seed >>> 0, style };
+}
+function rng(initial) {
+  let state = initial >>> 0;
+  return () => {
+    state = state * 1664525 + 1013904223 >>> 0;
+    return state / 2 ** 32;
+  };
+}
+function midi(n) {
+  return 440 * Math.pow(2, (n - 69) / 12);
+}
+function envelope(t, length) {
+  const attack = Math.min(0.04, length * 0.15);
+  const release = Math.min(0.18, length * 0.35);
+  if (t < attack)
+    return t / attack;
+  if (t > length - release)
+    return Math.max(0, (length - t) / release);
+  return 1;
+}
+function addNote(buffer, start, length, frequency, gain, kind, phase = 0) {
+  const from = Math.max(0, Math.floor(start * SAMPLE_RATE));
+  const to = Math.min(buffer.length, Math.ceil((start + length) * SAMPLE_RATE));
+  for (let i = from;i < to; i++) {
+    const t = i / SAMPLE_RATE - start;
+    const x = TAU * frequency * t + phase;
+    const wave = kind === "pad" ? Math.sin(x) * 0.75 + Math.sin(x * 2.01) * 0.18 : kind === "bass" ? Math.sin(x) * 0.8 + Math.sin(x * 2) * 0.2 : Math.sin(x) * 0.72 + Math.sin(x * 2) * 0.2 + Math.sin(x * 3) * 0.08;
+    const e = envelope(t, length) * (kind === "pad" ? 0.6 : 1);
+    buffer[i] += wave * gain * e;
+  }
+}
+function addKick(buffer, start, gain) {
+  const from = Math.floor(start * SAMPLE_RATE);
+  const length = 0.22;
+  for (let i = from;i < Math.min(buffer.length, from + length * SAMPLE_RATE); i++) {
+    const t = (i - from) / SAMPLE_RATE;
+    const frequency = 120 * Math.exp(-t * 18) + 42;
+    buffer[i] += Math.sin(TAU * frequency * t) * Math.exp(-t * 22) * gain;
+  }
+}
+function addHat(buffer, start, gain, random) {
+  const from = Math.floor(start * SAMPLE_RATE);
+  const length = 0.055;
+  for (let i = from;i < Math.min(buffer.length, from + length * SAMPLE_RATE); i++) {
+    const t = (i - from) / SAMPLE_RATE;
+    buffer[i] += (random() * 2 - 1) * Math.exp(-t * 75) * gain;
+  }
+}
+function makeTrack(duration, seed, styleName) {
+  const random = rng(seed);
+  const style = STYLES[styleName];
+  const total = Math.ceil(duration * SAMPLE_RATE);
+  const buffer = new Float32Array(total);
+  const bpm = Math.floor(style.bpm[0] + random() * (style.bpm[1] - style.bpm[0] + 1));
+  const beat = 60 / bpm;
+  const roots = [48, 45, 50, 43].map((n) => n + Math.floor(random() * 3));
+  const chordOffsets = style.chord;
+  for (let bar = 0, time = 0;time < duration; bar++, time += beat * 4) {
+    const root = roots[bar % roots.length];
+    for (const offset of chordOffsets)
+      addNote(buffer, time, beat * 4.2, midi(root + offset), style.pad, "pad");
+    addNote(buffer, time, beat * 2, midi(root - 12), style.bass, "bass");
+    addNote(buffer, time + beat * 2, beat * 2, midi(root - 12), style.bass * 0.85, "bass");
+    for (let b = 0;b < 4; b++) {
+      const beatTime = time + b * beat;
+      if (beatTime < duration)
+        addKick(buffer, beatTime, 0.2 * style.percussion);
+      if (beatTime + beat / 2 < duration)
+        addHat(buffer, beatTime + beat / 2, 0.035 * style.percussion, random);
+    }
+    for (let step = 0;step < 4; step++) {
+      if (random() > style.melodyDensity)
+        continue;
+      const note = root + 12 + chordOffsets[Math.floor(random() * chordOffsets.length)];
+      const noteTime = time + (step + 0.5) * beat;
+      if (noteTime < duration)
+        addNote(buffer, noteTime, beat * 0.38, midi(note), style.melody, "pluck", random() * TAU);
+    }
+  }
+  for (let i = 0;i < buffer.length; i++) {
+    const t = i / SAMPLE_RATE;
+    const fadeIn = Math.min(1, t / 0.35);
+    const fadeOut = Math.min(1, (duration - t) / 0.7);
+    buffer[i] = Math.max(-1, Math.min(1, buffer[i] * Math.max(0, Math.min(fadeIn, fadeOut))));
+  }
+  return { buffer, bpm };
+}
+function wavBytes(samples) {
+  const bytes = new ArrayBuffer(44 + samples.length * 2);
+  const view = new DataView(bytes);
+  const text = (offset, value) => [...value].forEach((c, i) => view.setUint8(offset + i, c.charCodeAt(0)));
+  text(0, "RIFF");
+  view.setUint32(4, 36 + samples.length * 2, true);
+  text(8, "WAVE");
+  text(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, SAMPLE_RATE, true);
+  view.setUint32(28, SAMPLE_RATE * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  text(36, "data");
+  view.setUint32(40, samples.length * 2, true);
+  samples.forEach((sample, i) => view.setInt16(44 + i * 2, sample < 0 ? sample * 32768 : sample * 32767, true));
+  return new Uint8Array(bytes);
+}
+async function main() {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    const track = makeTrack(options.duration, options.seed, options.style);
+    const temp = options.video ? `${options.output}.music.wav` : options.output;
+    await writeFile(temp, wavBytes(track.buffer));
+    if (options.video) {
+      const code = await new Promise((resolve, reject) => {
+        const proc = spawn("ffmpeg", ["-y", "-i", options.video, "-i", temp, "-map", "0:v:0", "-map", "1:a:0", "-c:v", "copy", "-c:a", "aac", "-shortest", options.output], { stdio: ["ignore", "inherit", "inherit"] });
+        proc.on("error", reject);
+        proc.on("close", (exitCode) => resolve(exitCode ?? 1));
+      });
+      if (code !== 0)
+        throw new Error("FFmpeg failed. Is it installed and on PATH?");
+      await unlink(temp);
+    }
+    console.log(`Created ${options.output} (${options.style}, ${options.duration}s, ${track.bpm} BPM, seed ${options.seed})`);
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  }
+}
+await main();

package/examples/README.md

@@ -0,0 +1,23 @@
+# tune examples
+
+This folder contains a generated 10-second `chill` track:
+
+<audio controls src="./chill.wav"></audio>
+
+If GitHub does not render the player in your context, download [chill.wav](./chill.wav) and play it locally.
+
+Generate your own examples from the project root:
+
+```bash
+bun run generate --duration 10 --style chill --seed 11 --output examples/chill.wav
+bun run generate --duration 10 --style upbeat --seed 27 --output examples/upbeat.wav
+bun run generate --duration 10 --style cinematic --seed 93 --output examples/cinematic.wav
+```
+
+Available styles:
+
+- `chill` — soft and spacious
+- `upbeat` — bright and rhythmic
+- `cinematic` — slow and expansive
+- `lofi` — mellow and understated
+- `playful` — bouncy and melodic

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@huozhi/tune",
+  "version": "0.1.0",
+  "description": "Generate short random procedural background music from the terminal",
+  "type": "module",
+  "bin": {
+    "tune": "dist/cli.js"
+  },
+  "scripts": {
+    "start": "bun src/cli.ts",
+    "generate": "bun src/cli.ts",
+    "build": "bun build src/cli.ts --target=node --format=esm --outfile=dist/cli.js",
+    "check": "bun run build && node dist/cli.js --help && npm pack --dry-run",
+    "prepublishOnly": "bun run build",
+    "web:dev": "cd web && bun devjar dev",
+    "web:build": "cd web && bun devjar build"
+  },
+  "files": ["dist", "README.md", "examples"],
+  "keywords": ["audio", "music", "generator", "procedural", "cli", "background-music"],
+  "engines": { "node": ">=22" },
+  "license": "MIT",
+  "devDependencies": {
+    "devjar": "^1.1.0"
+  }
+}