@litlab/audx 0.0.1 → 0.5.5

package/dist/bin.js

@@ -0,0 +1,1212 @@
+#!/usr/bin/env node
+import * as p from '@clack/prompts';
+import { existsSync, mkdirSync } from 'node:fs';
+import { readdir, readFile, writeFile, unlink } from 'node:fs/promises';
+import __node_cjsPath, { resolve, join, basename, isAbsolute } from 'node:path';
+import pc from 'picocolors';
+import { _ as _object_without_properties_loose } from './cc-DgCkkqq8.js';
+import __node_cjsModule from 'node:module';
+import __node_cjsUrl from 'node:url';
+
+const require$1 = __node_cjsModule.createRequire(import.meta.url);
+
+const REGISTRY_BASE = "https://audx.site/api";
+const CONFIG_DIR = ".themes";
+const CONFIG_FILE = "config.json";
+function configPath() {
+    return resolve(process.cwd(), CONFIG_DIR, CONFIG_FILE);
+}
+function getConfig() {
+    const p = configPath();
+    if (!existsSync(p)) return null;
+    try {
+        const raw = JSON.parse(require$1("node:fs").readFileSync(p, "utf-8"));
+        if (typeof raw.output === "string") return {
+            output: raw.output
+        };
+    } catch (unused) {}
+    return null;
+}
+async function ensureConfig(context = "setup") {
+    const existing = getConfig();
+    if (existing) return existing;
+    const isThemeContext = context === "themes";
+    const output = await p.select({
+        message: isThemeContext ? "Where should themes be installed?" : "Where should AudX be set up?",
+        options: isThemeContext ? [
+            {
+                value: "src/audio",
+                label: "src/audio/themes",
+                hint: "default"
+            },
+            {
+                value: "lib/audio",
+                label: "lib/audio/themes"
+            },
+            {
+                value: "__custom__",
+                label: "Custom path..."
+            }
+        ] : [
+            {
+                value: "src/audio",
+                label: "src/audio",
+                hint: "default"
+            },
+            {
+                value: "lib/audio",
+                label: "lib/audio"
+            },
+            {
+                value: "__custom__",
+                label: "Custom path..."
+            }
+        ]
+    });
+    if (p.isCancel(output)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    let outputDir = output;
+    if (outputDir === "__custom__") {
+        const custom = await p.text({
+            message: "Enter output path",
+            placeholder: isThemeContext ? "src/audio/themes" : "src/audio",
+            validate: (v)=>v.length === 0 ? "Path is required" : undefined
+        });
+        if (p.isCancel(custom)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        outputDir = normalizeConfigOutput(custom, context);
+    }
+    const config = {
+        output: outputDir
+    };
+    const dir = resolve(process.cwd(), CONFIG_DIR);
+    if (!existsSync(dir)) mkdirSync(dir, {
+        recursive: true
+    });
+    require$1("node:fs").writeFileSync(configPath(), `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+    return config;
+}
+function normalizeConfigOutput(output, context) {
+    const normalized = output.replace(/\/+$/, "");
+    if (context === "themes" && normalized.endsWith("/themes")) {
+        return normalized.slice(0, -"/themes".length);
+    }
+    return normalized;
+}
+function getPatchesDir() {
+    var _ref;
+    const config = getConfig();
+    const output = (_ref = config == null ? void 0 : config.output) != null ? _ref : "src/audio";
+    return resolve(process.cwd(), output, "themes");
+}
+function getSoundsDir() {
+    var _ref;
+    const config = getConfig();
+    const output = (_ref = config == null ? void 0 : config.output) != null ? _ref : "src/audio";
+    return resolve(process.cwd(), output, "a");
+}
+function parseGitHubSource(source) {
+    const normalizedSource = source.replace(/\/+$/, "").replace(/\.git$/, "");
+    const ghUrlMatch = normalizedSource.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\/tree\/([^/]+)(?:\/(.+))?)?$/);
+    if (ghUrlMatch) {
+        var _ghUrlMatch_, _ghUrlMatch_1;
+        return {
+            owner: ghUrlMatch[1],
+            repo: ghUrlMatch[2],
+            branch: (_ghUrlMatch_ = ghUrlMatch[3]) != null ? _ghUrlMatch_ : "main",
+            path: (_ghUrlMatch_1 = ghUrlMatch[4]) != null ? _ghUrlMatch_1 : ""
+        };
+    }
+    const shorthand = normalizedSource.match(/^([^/]+)\/([^/]+)$/);
+    if (shorthand) {
+        return {
+            owner: shorthand[1],
+            repo: shorthand[2],
+            branch: "main",
+            path: ""
+        };
+    }
+    return null;
+}
+async function discoverPatchesFromGitHub(source) {
+    const parsed = parseGitHubSource(source);
+    if (!parsed) {
+        throw new Error(`Invalid source: ${source}. Use owner/repo or a GitHub URL.`);
+    }
+    const { owner, repo, branch, path: subPath } = parsed;
+    const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`;
+    const res = await fetch(treeUrl, {
+        headers: {
+            Accept: "application/vnd.github.v3+json"
+        }
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to fetch repo tree: ${res.status}`);
+    }
+    const tree = await res.json();
+    const jsonFiles = tree.tree.filter((item)=>{
+        if (item.type !== "blob" || !item.path.endsWith(".json")) return false;
+        if (subPath && !item.path.startsWith(subPath)) return false;
+        if (item.path.includes("node_modules/")) return false;
+        if (item.path.includes("package.json")) return false;
+        if (item.path.includes("tsconfig")) return false;
+        if (item.path.includes(".changeset/")) return false;
+        return true;
+    });
+    const patches = [];
+    for (const file of jsonFiles){
+        const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${file.path}`;
+        try {
+            const r = await fetch(rawUrl);
+            if (!r.ok) continue;
+            const data = await r.json();
+            if (!validatePatch(data)) continue;
+            patches.push({
+                name: data.name,
+                path: file.path,
+                downloadUrl: rawUrl,
+                description: data.description,
+                soundCount: Object.keys(data.sounds).length
+            });
+        } catch (unused) {}
+    }
+    return patches;
+}
+function isGitHubSource(source) {
+    return parseGitHubSource(source) !== null;
+}
+function isLocalSource(source) {
+    if (source.startsWith("http://") || source.startsWith("https://")) {
+        return false;
+    }
+    const abs = isAbsolute(source) ? source : resolve(process.cwd(), source);
+    return existsSync(abs);
+}
+async function discoverPatchesFromLocal(source) {
+    const abs = isAbsolute(source) ? source : resolve(process.cwd(), source);
+    if (abs.endsWith(".json")) {
+        const raw = await readFile(abs, "utf-8");
+        const data = JSON.parse(raw);
+        if (!validatePatch(data)) {
+            throw new Error(`${source} is not a valid sound patch.`);
+        }
+        return [
+            {
+                name: data.name,
+                path: abs,
+                downloadUrl: abs,
+                description: data.description,
+                soundCount: Object.keys(data.sounds).length
+            }
+        ];
+    }
+    const files = await readdir(abs);
+    const patches = [];
+    for (const file of files){
+        if (!file.endsWith(".json") || file === "index.json") continue;
+        try {
+            const filePath = join(abs, file);
+            const raw = await readFile(filePath, "utf-8");
+            const data = JSON.parse(raw);
+            if (!validatePatch(data)) continue;
+            patches.push({
+                name: data.name,
+                path: filePath,
+                downloadUrl: filePath,
+                description: data.description,
+                soundCount: Object.keys(data.sounds).length
+            });
+        } catch (unused) {}
+    }
+    return patches;
+}
+async function fetchPatchIndex() {
+    const res = await fetch(`${REGISTRY_BASE}/patches`);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch patch index: ${res.status}`);
+    }
+    return res.json();
+}
+async function fetchPatchJson(nameOrUrl) {
+    const url = nameOrUrl.startsWith("http") ? nameOrUrl : `${REGISTRY_BASE}/patch/${nameOrUrl}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch patch: ${res.status}`);
+    }
+    return res.json();
+}
+async function registerPatch(url) {
+    try {
+        await fetch(`${REGISTRY_BASE}/patches`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                url
+            })
+        });
+    } catch (unused) {}
+}
+function validatePatch(data) {
+    return typeof data.name === "string" && typeof data.sounds === "object" && data.sounds !== null;
+}
+async function getInstalledPatches() {
+    const dir = getPatchesDir();
+    if (!existsSync(dir)) return [];
+    const files = await readdir(dir);
+    const patches = [];
+    for (const file of files){
+        if (!file.endsWith(".ts") || file === "index.ts") continue;
+        try {
+            var _raw_match, _ref;
+            const raw = await readFile(join(dir, file), "utf-8");
+            const nameMatch = raw.match(/^\/\/ patch: (.+)$/m);
+            const exportCount = ((_raw_match = raw.match(/^export const /gm)) != null ? _raw_match : []).length;
+            const name = (_ref = nameMatch == null ? void 0 : nameMatch[1]) != null ? _ref : basename(file, ".ts");
+            patches.push({
+                file,
+                name,
+                soundCount: Math.max(0, exportCount - 1)
+            });
+        } catch (unused) {}
+    }
+    return patches;
+}
+const RESERVED = new Set([
+    "break",
+    "case",
+    "catch",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "in",
+    "instanceof",
+    "new",
+    "return",
+    "switch",
+    "this",
+    "throw",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "class",
+    "const",
+    "enum",
+    "export",
+    "extends",
+    "import",
+    "super",
+    "implements",
+    "interface",
+    "let",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "static",
+    "yield",
+    "await"
+]);
+function toCamelCase(s) {
+    let id = s.replace(/[^a-zA-Z0-9]+(.)/g, (_, c)=>c.toUpperCase()).replace(/^[^a-zA-Z_$]/, "_$&");
+    if (RESERVED.has(id)) id = `_${id}`;
+    return id;
+}
+function toIdentifier(s) {
+    return toCamelCase(s);
+}
+function generateModule(data) {
+    const entries = Object.entries(data.sounds);
+    const ids = entries.map(([key])=>toCamelCase(key));
+    const lines = [
+        `// ${data.name} — generated by @litlab/audx (do not edit)`,
+        `// patch: ${data.name}`,
+        `import type { SoundDefinition, SoundPatch } from "@litlab/audx";`,
+        ""
+    ];
+    for(let i = 0; i < entries.length; i++){
+        const [, def] = entries[i];
+        lines.push(`export const ${ids[i]}: SoundDefinition = ${JSON.stringify(def)};`);
+    }
+    const { sounds: _, $schema: _s } = data, meta = _object_without_properties_loose(data, [
+        "sounds",
+        "$schema"
+    ]);
+    const soundsObj = ids.map((id, i)=>{
+        const key = entries[i][0];
+        return id === key ? id : `${JSON.stringify(key)}: ${id}`;
+    });
+    lines.push("", `export const _patch: SoundPatch = {`, `  ...${JSON.stringify(meta)},`, `  sounds: { ${soundsObj.join(", ")} },`, `};`, "");
+    return lines.join("\n");
+}
+function generateSoundModule(name, definition) {
+    const id = toCamelCase(name);
+    return [
+        `import { defineSound } from "@litlab/audx";`,
+        "",
+        `export const ${id} = defineSound(${JSON.stringify(definition, null, 2)});`,
+        ""
+    ].join("\n");
+}
+async function regenerateIndex(dir) {
+    if (!existsSync(dir)) return;
+    const files = await readdir(dir);
+    const modules = files.filter((f)=>f.endsWith(".ts") && f !== "index.ts").map((f)=>basename(f, ".ts")).sort();
+    const lines = [
+        "// generated by @litlab/audx (do not edit)",
+        ...modules.map((m)=>`export * as ${toCamelCase(m)} from "./${m}";`),
+        ""
+    ];
+    await writeFile(join(dir, "index.ts"), lines.join("\n"), "utf-8");
+}
+
+function parseAddOptions(args) {
+    const options = {};
+    let source;
+    for(let i = 0; i < args.length; i++){
+        const arg = args[i];
+        if (arg === "-y" || arg === "--yes") {
+            options.yes = true;
+        } else if (arg === "-l" || arg === "--list") {
+            options.list = true;
+        } else if (arg === "--patch") {
+            options.patch = args[++i];
+        } else if (arg && !arg.startsWith("-")) {
+            source = arg;
+        }
+    }
+    return {
+        source,
+        options
+    };
+}
+async function add(args) {
+    const { source, options } = parseAddOptions(args);
+    p.intro("@litlab/audx add");
+    if (!source) {
+        await addFromRegistry(options);
+        return;
+    }
+    if (isLocalSource(source)) {
+        await addFromLocal(source, options);
+        return;
+    }
+    if (source.startsWith("http") && source.endsWith(".json")) {
+        await addFromUrl(source, options);
+        return;
+    }
+    if (isGitHubSource(source)) {
+        await addFromGitHub(source, options);
+        return;
+    }
+    await addSoundFromRegistry(source, options);
+}
+async function addFromLocal(source, options) {
+    const s = p.spinner();
+    s.start("Scanning local path for patches...");
+    let discovered;
+    try {
+        discovered = await discoverPatchesFromLocal(source);
+        s.stop(`Found ${discovered.length} patch(es)`);
+    } catch (err) {
+        s.stop("Failed to scan local path.");
+        p.log.error(String(err));
+        process.exit(1);
+    }
+    if (discovered.length === 0) {
+        p.log.warn("No valid sound patches found at this path.");
+        p.outro("Patches must be JSON files with a name and sounds object.");
+        return;
+    }
+    if (options.list) {
+        printPatchList(discovered);
+        return;
+    }
+    const toInstall = selectPatches(discovered, options);
+    if (!toInstall || toInstall.length === 0) return;
+    const installed = await getInstalledPatches();
+    const installedNames = new Set(installed.map((p)=>p.name));
+    const final = options.yes ? toInstall : await confirmOverwrites(toInstall, installedNames);
+    if (!final || final.length === 0) return;
+    const dl = p.spinner();
+    dl.start(`Installing ${final.length} patch(es)...`);
+    const results = [];
+    for (const patch of final){
+        try {
+            const raw = await readFile(patch.downloadUrl, "utf-8");
+            const data = JSON.parse(raw);
+            if (!validatePatch(data)) {
+                p.log.warn(`Skipping ${patch.name}: invalid patch format`);
+                continue;
+            }
+            await writePatch(patch.name, data);
+            results.push(data.name);
+        } catch (err) {
+            p.log.warn(`Failed to install ${patch.name}: ${err}`);
+        }
+    }
+    dl.stop(`Installed ${results.length} patch(es)`);
+    p.note(results.map((n)=>`  - ${n}`).join("\n"), "Installed patches");
+    p.outro("Done!");
+}
+async function addFromGitHub(source, options) {
+    const s = p.spinner();
+    s.start("Scanning repository for patches...");
+    let discovered;
+    try {
+        discovered = await discoverPatchesFromGitHub(source);
+        s.stop(`Found ${discovered.length} patch(es)`);
+    } catch (err) {
+        s.stop("Failed to scan repository.");
+        p.log.error(String(err));
+        process.exit(1);
+    }
+    if (discovered.length === 0) {
+        p.log.warn("No valid sound patches found in this repository.");
+        p.outro("Patches must be JSON files with a name and sounds object.");
+        return;
+    }
+    if (options.list) {
+        printPatchList(discovered);
+        return;
+    }
+    const installed = await getInstalledPatches();
+    const installedNames = new Set(installed.map((p)=>p.name));
+    const toInstall = await resolvePatchSelection(discovered, installedNames, options);
+    if (!toInstall || toInstall.length === 0) return;
+    const dl = p.spinner();
+    dl.start(`Installing ${toInstall.length} patch(es)...`);
+    const results = [];
+    for (const patch of toInstall){
+        try {
+            const data = await fetchPatchJson(patch.downloadUrl);
+            if (!validatePatch(data)) {
+                p.log.warn(`Skipping ${patch.name}: invalid patch format`);
+                continue;
+            }
+            await writePatch(patch.name, data);
+            registerPatch(patch.downloadUrl);
+            results.push(data.name);
+        } catch (err) {
+            p.log.warn(`Failed to install ${patch.name}: ${err}`);
+        }
+    }
+    dl.stop(`Installed ${results.length} patch(es)`);
+    p.note(results.map((n)=>`  - ${n}`).join("\n"), "Installed patches");
+    p.outro("Done!");
+}
+async function addFromUrl(url, options) {
+    const s = p.spinner();
+    s.start("Fetching patch...");
+    try {
+        const data = await fetchPatchJson(url);
+        if (!validatePatch(data)) {
+            s.stop("Invalid patch format.");
+            p.log.error("The fetched JSON is not a valid sound patch (missing name or sounds).");
+            process.exit(1);
+        }
+        s.stop(`Fetched "${data.name}"`);
+        if (options.list) {
+            console.log(`  ${pc.bold(data.name)}  ${pc.dim(`${Object.keys(data.sounds).length} sounds`)}`);
+            console.log();
+            return;
+        }
+        await writePatch(data.name, data);
+        registerPatch(url);
+    } catch (err) {
+        s.stop("Failed to fetch patch.");
+        p.log.error(String(err));
+        process.exit(1);
+    }
+}
+async function addFromRegistry(options) {
+    const s = p.spinner();
+    s.start("Fetching available patches...");
+    let index;
+    try {
+        index = await fetchPatchIndex();
+        s.stop(`Found ${index.length} patches`);
+    } catch (err) {
+        s.stop("Failed to fetch patch index.");
+        p.log.error(String(err));
+        process.exit(1);
+    }
+    if (options.list) {
+        console.log();
+        for (const entry of index){
+            console.log(`  ${pc.bold(entry.name)}  ${pc.dim(entry.description)}`);
+        }
+        console.log();
+        return;
+    }
+    const installed = await getInstalledPatches();
+    const installedNames = new Set(installed.map((p)=>p.name));
+    let names;
+    if (options.patch) {
+        const patchName = options.patch;
+        names = [
+            patchName
+        ];
+        const match = index.find((e)=>e.name.toLowerCase() === patchName.toLowerCase());
+        if (!match) {
+            p.log.error(`Patch "${patchName}" not found in registry.`);
+            process.exit(1);
+        }
+    } else if (options.yes) {
+        names = index.map((e)=>e.name);
+    } else {
+        const selected = await p.multiselect({
+            message: "Select patches to install",
+            options: index.map((entry)=>({
+                    value: entry.name,
+                    label: `${entry.name}${installedNames.has(entry.name) ? " (installed)" : ""}`,
+                    hint: entry.description
+                }))
+        });
+        if (p.isCancel(selected)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        names = selected;
+        if (names.length === 0) {
+            p.outro("No patches selected.");
+            return;
+        }
+    }
+    if (!options.yes) {
+        const existing = names.filter((n)=>installedNames.has(n));
+        if (existing.length > 0) {
+            const overwrite = await p.confirm({
+                message: `${existing.length} patch(es) already installed. Overwrite?`
+            });
+            if (p.isCancel(overwrite) || !overwrite) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+        }
+    }
+    const dl = p.spinner();
+    dl.start(`Downloading ${names.length} patch(es)...`);
+    const results = [];
+    for (const name of names){
+        try {
+            const data = await fetchPatchJson(name);
+            if (!validatePatch(data)) {
+                p.log.warn(`Skipping ${name}: invalid patch format`);
+                continue;
+            }
+            await writePatch(name, data);
+            results.push(data.name);
+        } catch (err) {
+            p.log.warn(`Failed to download ${name}: ${err}`);
+        }
+    }
+    dl.stop(`Downloaded ${results.length} patch(es)`);
+    p.note(results.map((n)=>`  - ${n}`).join("\n"), "Installed patches");
+    p.outro("Done!");
+}
+async function addSoundFromRegistry(soundName, options) {
+    if (options.list) {
+        p.log.error("--list is only available when browsing themes.");
+        process.exit(1);
+    }
+    const s = p.spinner();
+    s.start(`Finding "${soundName}"...`);
+    let index;
+    try {
+        index = await fetchPatchIndex();
+    } catch (err) {
+        s.stop("Failed to fetch theme index.");
+        p.log.error(String(err));
+        process.exit(1);
+    }
+    let found;
+    for (const entry of index){
+        try {
+            const data = await fetchPatchJson(entry.name);
+            if (!validatePatch(data)) continue;
+            const match = Object.entries(data.sounds).find(([name])=>name.toLowerCase() === soundName.toLowerCase());
+            if (match) {
+                found = {
+                    theme: data.name,
+                    definition: match[1]
+                };
+                break;
+            }
+        } catch (unused) {}
+    }
+    if (!found) {
+        s.stop(`Sound "${soundName}" not found.`);
+        p.log.error("Run `@litlab/audx add` to browse available themes.");
+        process.exit(1);
+    }
+    s.stop(`Found "${soundName}" in ${found.theme}`);
+    await writeSound(soundName, found.definition, options);
+    p.note(`  - ${soundName}`, "Installed sound");
+    p.outro("Done!");
+}
+function printPatchList(patches) {
+    console.log();
+    for (const patch of patches){
+        const desc = patch.description ? `  ${pc.dim(patch.description)}` : "";
+        console.log(`  ${pc.bold(patch.name)}  ${pc.dim(`${patch.soundCount} sounds`)}${desc}`);
+    }
+    console.log();
+}
+function selectPatches(discovered, options) {
+    if (options.patch) {
+        const patchName = options.patch;
+        const match = discovered.filter((d)=>d.name.toLowerCase() === patchName.toLowerCase());
+        if (match.length === 0) {
+            p.log.error(`Patch "${patchName}" not found.`);
+            process.exit(1);
+        }
+        return match;
+    }
+    if (options.yes) return discovered;
+    return discovered;
+}
+async function resolvePatchSelection(discovered, installedNames, options) {
+    if (options.patch) {
+        const patchName = options.patch;
+        const match = discovered.filter((d)=>d.name.toLowerCase() === patchName.toLowerCase());
+        if (match.length === 0) {
+            p.log.error(`Patch "${patchName}" not found.`);
+            process.exit(1);
+        }
+        return match;
+    }
+    if (options.yes) return discovered;
+    if (discovered.length === 1) return discovered;
+    return await promptPatchSelection(discovered, installedNames);
+}
+async function promptPatchSelection(discovered, installedNames) {
+    const selected = await p.multiselect({
+        message: "Select patches to install",
+        options: discovered.map((patch)=>({
+                value: patch.name,
+                label: `${patch.name}${installedNames.has(patch.name) ? " (installed)" : ""}`,
+                hint: patch.description ? `${patch.soundCount} sounds — ${patch.description}` : `${patch.soundCount} sounds`
+            }))
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    const names = new Set(selected);
+    return discovered.filter((d)=>names.has(d.name));
+}
+async function confirmOverwrites(patches, installedNames) {
+    const existing = patches.filter((patch)=>installedNames.has(patch.name));
+    if (existing.length === 0) return patches;
+    const overwrite = await p.confirm({
+        message: `${existing.length} patch(es) already installed. Overwrite?`
+    });
+    if (p.isCancel(overwrite) || !overwrite) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    return patches;
+}
+async function writePatch(filename, data) {
+    await ensureConfig("themes");
+    const dir = getPatchesDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, {
+            recursive: true
+        });
+    }
+    const slug = filename.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    const moduleSource = generateModule(data);
+    const target = join(dir, `${slug}.ts`);
+    await writeFile(target, moduleSource, "utf-8");
+    await regenerateIndex(dir);
+}
+async function writeSound(name, definition, options) {
+    await ensureConfig("setup");
+    const dir = getSoundsDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, {
+            recursive: true
+        });
+    }
+    const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    const target = join(dir, `${slug}.ts`);
+    if (existsSync(target) && !options.yes) {
+        const overwrite = await p.confirm({
+            message: `${slug}.ts already exists. Overwrite?`
+        });
+        if (p.isCancel(overwrite) || !overwrite) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+    }
+    await writeFile(target, generateSoundModule(toIdentifier(name), definition), "utf-8");
+}
+
+async function check(_args) {
+    p.intro("@litlab/audx check");
+    const installed = await getInstalledPatches();
+    if (installed.length === 0) {
+        p.log.warn("No patches installed.");
+        p.outro("Install patches with npx @litlab/audx add");
+        return;
+    }
+    const s = p.spinner();
+    s.start("Checking for updates...");
+    let registry;
+    try {
+        registry = await fetchPatchIndex();
+        s.stop(`Checked ${registry.length} registry patch(es)`);
+    } catch (err) {
+        s.stop("Failed to fetch registry.");
+        p.log.error(String(err));
+        process.exit(1);
+    }
+    const registryMap = new Map(registry.map((e)=>[
+            e.name.toLowerCase(),
+            e
+        ]));
+    const available = [];
+    const notInRegistry = [];
+    for (const entry of installed){
+        const regEntry = registryMap.get(entry.name.toLowerCase());
+        if (regEntry) {
+            available.push(entry.name);
+        } else {
+            notInRegistry.push(entry.name);
+        }
+    }
+    if (available.length === 0) {
+        p.log.warn("No installed patches found in the registry.");
+        p.outro("");
+        return;
+    }
+    p.note(available.map((name)=>`  ↑ ${name}`).join("\n"), `${available.length} patch(es) available`);
+    if (notInRegistry.length > 0) {
+        p.log.warn([
+            `${notInRegistry.length} patch(es) not found in registry:`,
+            ...notInRegistry.map((name)=>`  • ${name}`)
+        ].join("\n"));
+    }
+    p.outro("Run npx @litlab/audx update to re-download latest versions");
+}
+
+async function find(args) {
+    const query = args.join(" ").toLowerCase();
+    p.intro("@litlab/audx find");
+    const s = p.spinner();
+    s.start("Fetching registry...");
+    let index;
+    try {
+        index = await fetchPatchIndex();
+        s.stop(`Found ${index.length} patch(es) in registry`);
+    } catch (err) {
+        s.stop("Failed to fetch registry.");
+        p.log.error(String(err));
+        process.exit(1);
+    }
+    if (index.length === 0) {
+        p.log.warn("No patches available in the registry.");
+        p.outro("");
+        return;
+    }
+    const matches = query ? index.filter((entry)=>{
+        var _entry_tags;
+        const haystack = `${entry.name} ${entry.description} ${((_entry_tags = entry.tags) != null ? _entry_tags : []).join(" ")}`.toLowerCase();
+        return haystack.includes(query);
+    }) : index;
+    if (matches.length === 0) {
+        p.log.warn(`No patches found for "${query}"`);
+        p.outro("");
+        return;
+    }
+    p.log.info("Install with npx @litlab/audx add --patch <name>");
+    for (const entry of matches){
+        const tags = entry.tags && entry.tags.length > 0 ? `  ${entry.tags.join(", ")}` : "";
+        const desc = entry.description ? `\n  ${entry.description}` : "";
+        p.log.step(`${entry.name}${tags}${desc}`);
+    }
+    p.outro(`${matches.length} result(s)`);
+}
+
+async function init(args) {
+    if (args[0] === "theme") {
+        await themeInit(args.slice(1));
+        return;
+    }
+    p.intro("@litlab/audx init");
+    await ensureConfig();
+    await add([]);
+}
+async function themeInit(_args) {
+    p.intro("@litlab/audx theme init");
+    const name = await p.text({
+        message: "Patch name",
+        placeholder: "my-patch",
+        validate: (v)=>v.length === 0 ? "Name is required" : undefined
+    });
+    if (p.isCancel(name)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    const author = await p.text({
+        message: "Author",
+        placeholder: "Your name"
+    });
+    if (p.isCancel(author)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    const description = await p.text({
+        message: "Description",
+        placeholder: "What does this patch sound like?"
+    });
+    if (p.isCancel(description)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    const filename = `${slug}.json`;
+    const dir = resolve(process.cwd(), ".audx", "themes");
+    if (!existsSync(dir)) {
+        mkdirSync(dir, {
+            recursive: true
+        });
+    }
+    const target = resolve(dir, filename);
+    if (existsSync(target)) {
+        const overwrite = await p.confirm({
+            message: `${filename} already exists. Overwrite?`
+        });
+        if (p.isCancel(overwrite) || !overwrite) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+    }
+    const patch = {
+        $schema: "../../node_modules/@litlab/audx/schemas/patch.schema.json",
+        name: name,
+        author: author || undefined,
+        version: "1.0.0",
+        description: description || undefined,
+        tags: [],
+        sounds: {}
+    };
+    await writeFile(target, `${JSON.stringify(patch, null, 2)}\n`, "utf-8");
+    p.log.success(`Created .audx/themes/${filename}`);
+    p.outro("Add sounds to the `sounds` object to get started.");
+}
+
+async function list(_args) {
+    p.intro("@litlab/audx list");
+    const patches = await getInstalledPatches();
+    if (patches.length === 0) {
+        p.log.warn(`No patches found in ${getPatchesDir()}`);
+        p.outro("Run `@litlab/audx add` to install patches.");
+        return;
+    }
+    const rows = patches.map((patch)=>{
+        var _patch_description;
+        return `  ${patch.name.padEnd(16)} ${String(patch.soundCount).padStart(3)} sounds   ${(_patch_description = patch.description) != null ? _patch_description : ""}`;
+    });
+    p.note(rows.join("\n"), `${patches.length} patch(es) installed`);
+    p.outro(getPatchesDir());
+}
+
+function parseRemoveOptions(args) {
+    const options = {};
+    const patches = [];
+    for(let i = 0; i < args.length; i++){
+        const arg = args[i];
+        if (arg === "-y" || arg === "--yes") {
+            options.yes = true;
+        } else if (arg && !arg.startsWith("-")) {
+            patches.push(arg);
+        }
+    }
+    return {
+        patches,
+        options
+    };
+}
+async function remove(args) {
+    const { patches: patchNames, options } = parseRemoveOptions(args);
+    p.intro("@litlab/audx remove");
+    const patches = await getInstalledPatches();
+    if (patches.length === 0) {
+        p.log.warn("No patches installed.");
+        p.outro("Nothing to remove.");
+        return;
+    }
+    let files;
+    if (patchNames.length > 0) {
+        const matched = patches.filter((pk)=>patchNames.some((n)=>n.toLowerCase() === pk.name.toLowerCase()));
+        if (matched.length === 0) {
+            p.log.error(`No matching patches found for: ${patchNames.join(", ")}`);
+            return;
+        }
+        files = matched.map((pk)=>pk.file);
+    } else {
+        const selected = await p.multiselect({
+            message: "Select patches to remove",
+            options: patches.map((pk)=>({
+                    value: pk.file,
+                    label: pk.name,
+                    hint: `${pk.soundCount} sounds`
+                }))
+        });
+        if (p.isCancel(selected)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        files = selected;
+        if (files.length === 0) {
+            p.outro("No patches selected.");
+            return;
+        }
+    }
+    if (!options.yes) {
+        const confirmed = await p.confirm({
+            message: `Remove ${files.length} patch(es)?`
+        });
+        if (p.isCancel(confirmed) || !confirmed) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+    }
+    const dir = getPatchesDir();
+    const removed = [];
+    for (const file of files){
+        try {
+            var _ref;
+            await unlink(join(dir, file));
+            const pk = patches.find((item)=>item.file === file);
+            removed.push((_ref = pk == null ? void 0 : pk.name) != null ? _ref : file);
+        } catch (err) {
+            p.log.warn(`Failed to remove ${file}: ${err}`);
+        }
+    }
+    await regenerateIndex(dir);
+    p.note(removed.map((n)=>`  - ${n}`).join("\n"), "Removed patches");
+    p.outro("Done!");
+}
+
+async function update(_args) {
+    p.intro("@litlab/audx update");
+    const installed = await getInstalledPatches();
+    if (installed.length === 0) {
+        p.log.warn("No patches installed.");
+        p.outro("Install patches with npx @litlab/audx add");
+        return;
+    }
+    const s = p.spinner();
+    s.start("Fetching registry...");
+    let registry;
+    try {
+        registry = await fetchPatchIndex();
+        s.stop(`Found ${registry.length} registry patch(es)`);
+    } catch (err) {
+        s.stop("Failed to fetch registry.");
+        p.log.error(String(err));
+        process.exit(1);
+    }
+    const registryMap = new Map(registry.map((e)=>[
+            e.name.toLowerCase(),
+            e
+        ]));
+    const toUpdate = installed.filter((pk)=>registryMap.has(pk.name.toLowerCase()));
+    if (toUpdate.length === 0) {
+        p.log.warn("No installed patches found in the registry.");
+        p.outro("");
+        return;
+    }
+    const dl = p.spinner();
+    dl.start(`Updating ${toUpdate.length} patch(es)...`);
+    let successCount = 0;
+    let failCount = 0;
+    const dir = getPatchesDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, {
+            recursive: true
+        });
+    }
+    for (const entry of toUpdate){
+        try {
+            const data = await fetchPatchJson(entry.name);
+            if (!validatePatch(data)) {
+                failCount++;
+                continue;
+            }
+            const slug = entry.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+            const moduleSource = generateModule(data);
+            const target = join(dir, `${slug}.ts`);
+            await writeFile(target, moduleSource, "utf-8");
+            successCount++;
+        } catch (unused) {
+            failCount++;
+        }
+    }
+    await regenerateIndex(dir);
+    dl.stop(`Updated ${successCount} patch(es)`);
+    if (failCount > 0) {
+        p.log.warn(`Failed to update ${failCount} patch(es)`);
+    }
+    p.outro("Done!");
+}
+
+const __filename$1 = __node_cjsUrl.fileURLToPath(import.meta.url);
+__node_cjsPath.dirname(__filename$1);
+
+const COMMANDS = {
+    add,
+    a: add,
+    find,
+    search: find,
+    f: find,
+    s: find,
+    list,
+    ls: list,
+    remove,
+    rm: remove,
+    check,
+    update,
+    upgrade: update,
+    init,
+    theme: async (args)=>{
+        if (args[0] !== "init") {
+            var _args_;
+            p.log.error(`Unknown theme command: ${(_args_ = args[0]) != null ? _args_ : ""}`);
+            p.log.message("Run @litlab/audx theme init to create a new theme.");
+            process.exit(1);
+        }
+        await themeInit(args.slice(1));
+    }
+};
+function showBanner() {
+    p.intro("@litlab/audx");
+    p.log.message("Manage sound patches for your project.");
+    p.log.message([
+        "Patches",
+        "  add [sound]     Install an individual sound",
+        "  add             Browse and install themes",
+        "  find [query]    Search for patches",
+        "  list            List installed patches",
+        "  remove          Remove installed patches"
+    ].join("\n"));
+    p.log.message([
+        "Updates",
+        "  check           Check for updates",
+        "  update          Update installed patches"
+    ].join("\n"));
+    p.log.message([
+        "Project",
+        "  init            Set up AudX and install themes",
+        "  theme init      Create a new local theme JSON"
+    ].join("\n"));
+    p.outro("try: npx @litlab/audx add ommgh/audio");
+}
+function showHelp() {
+    p.intro("@litlab/audx");
+    p.log.message([
+        "Usage: @litlab/audx <command> [options]",
+        "",
+        "Manage Patches:",
+        "  add [sound]     Install an individual sound",
+        "  add             Browse and install themes",
+        "  add <source>    Install themes from a source",
+        "  find [query]    Search for patches in the registry",
+        "  list, ls        List installed patches",
+        "  remove, rm      Remove installed patches",
+        "",
+        "Updates:",
+        "  check           Check for available updates",
+        "  update          Update all installed patches",
+        "",
+        "Project:",
+        "  init            Set up AudX and install themes",
+        "  theme init      Create a new local theme JSON"
+    ].join("\n"));
+    p.log.message([
+        "Add Options:",
+        "  -l, --list      Preview available patches without installing",
+        "  -y, --yes       Skip confirmation prompts",
+        "  --patch <name>  Install a specific patch by name",
+        "",
+        "Remove Options:",
+        "  -y, --yes       Skip confirmation prompts"
+    ].join("\n"));
+    p.log.message([
+        "Source Formats:",
+        "  ./local/path                    Local file or directory",
+        "  owner/repo                      GitHub shorthand",
+        "  https://github.com/user/repo    Full GitHub URL",
+        "  https://...patch.json           Direct URL to a patch file",
+        "  (no argument)                   Browse the registry"
+    ].join("\n"));
+    p.log.message([
+        "Options:",
+        "  --help, -h      Show this help message",
+        "  --version, -v   Show version number"
+    ].join("\n"));
+    p.note([
+        "  @litlab/audx add ommgh/audio",
+        "  @litlab/audx add ./.themes/",
+        "  @litlab/audx add ommgh/audio --list",
+        "  @litlab/audx add --patch core -y",
+        "  @litlab/audx remove core -y",
+        "  @litlab/audx find ambient",
+        "  @litlab/audx check",
+        "  @litlab/audx update"
+    ].join("\n"), "Examples");
+    p.outro("");
+}
+async function run() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (!command) {
+        showBanner();
+        return;
+    }
+    if (command === "--help" || command === "-h") {
+        showHelp();
+        return;
+    }
+    if (command === "--version" || command === "-v") {
+        try {
+            const { readFileSync } = await import('node:fs');
+            const { join, dirname } = await import('node:path');
+            const { fileURLToPath } = await import('node:url');
+            const __dirname = dirname(fileURLToPath(import.meta.url));
+            const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+            console.log(pkg.version);
+        } catch (unused) {
+            console.log("0.0.0");
+        }
+        return;
+    }
+    const handler = COMMANDS[command];
+    if (!handler) {
+        p.log.error(`Unknown command: ${command}`);
+        p.log.message("Run @litlab/audx --help for usage information.");
+        process.exit(1);
+    }
+    await handler(args.slice(1));
+}
+
+run();