klaudio 0.1.0

package/src/presets.js

@@ -0,0 +1,75 @@
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Detect compiled bun binary: import.meta.url starts with "bun:" or "B:/"
+const isCompiledBinary = import.meta.url.startsWith("bun:") || import.meta.url.startsWith("B:/~BUN/");
+const SOUNDS_DIR = isCompiledBinary
+  ? join(dirname(process.execPath), "sounds")
+  : join(__dirname, "..", "sounds");
+
+/**
+ * Sound events that can be configured.
+ */
+export const EVENTS = {
+  stop: {
+    name: "Task Complete",
+    description: "Plays when Claude finishes a response",
+    hookEvent: "Stop",
+  },
+  notification: {
+    name: "Notification",
+    description: "Plays when Claude needs your attention",
+    hookEvent: "Notification",
+  },
+};
+
+/**
+ * Built-in presets with their sound file mappings.
+ */
+export const PRESETS = {
+  "retro-8bit": {
+    name: "Retro 8-bit",
+    icon: "🎮",
+    description: "Chiptune bleeps, bloops, and victory jingles",
+    sounds: {
+      stop: join(SOUNDS_DIR, "retro-8bit", "stop.wav"),
+      notification: join(SOUNDS_DIR, "retro-8bit", "notification.wav"),
+    },
+  },
+  "minimal-zen": {
+    name: "Minimal Zen",
+    icon: "🔔",
+    description: "Soft chimes and gentle tones",
+    sounds: {
+      stop: join(SOUNDS_DIR, "minimal-zen", "stop.wav"),
+      notification: join(SOUNDS_DIR, "minimal-zen", "notification.wav"),
+    },
+  },
+  "sci-fi-terminal": {
+    name: "Sci-Fi Terminal",
+    icon: "🚀",
+    description: "Futuristic UI bleeps and digital notifications",
+    sounds: {
+      stop: join(SOUNDS_DIR, "sci-fi-terminal", "stop.wav"),
+      notification: join(SOUNDS_DIR, "sci-fi-terminal", "notification.wav"),
+    },
+  },
+  "victory-fanfare": {
+    name: "Victory Fanfare",
+    icon: "🏆",
+    description: "Celebratory jingles for task completion",
+    sounds: {
+      stop: join(SOUNDS_DIR, "victory-fanfare", "stop.wav"),
+      notification: join(SOUNDS_DIR, "victory-fanfare", "notification.wav"),
+    },
+  },
+};
+
+export function getPresetSoundPath(presetId, eventId) {
+  return PRESETS[presetId]?.sounds[eventId];
+}
+
+export function getSoundsDir() {
+  return SOUNDS_DIR;
+}

package/src/scanner.js

@@ -0,0 +1,370 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, extname } from "node:path";
+import { platform, homedir } from "node:os";
+
+const AUDIO_EXTENSIONS = new Set([".wav", ".mp3", ".ogg", ".flac", ".aac"]);
+const PACKED_EXTENSIONS = new Set([".wem", ".bnk", ".bank", ".fsb", ".pck"]);
+const MAX_DEPTH = 5;
+const MAX_FILES = 200;
+
+/** Yield to the event loop so the UI stays responsive. */
+const tick = () => new Promise((r) => setTimeout(r, 0));
+
+/**
+ * Check if a directory exists and is accessible.
+ */
+async function dirExists(dirPath) {
+  try {
+    const s = await stat(dirPath);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Discover available drive letters on Windows (C-Z).
+ */
+async function getWindowsDrives() {
+  const drives = [];
+  for (const letter of "CDEFGHIJKLMNOPQRSTUVWXYZ") {
+    if (await dirExists(`${letter}:/`)) {
+      drives.push(`${letter}:`);
+    }
+  }
+  return drives;
+}
+
+/**
+ * Parse Steam's libraryfolders.vdf to find all Steam library paths.
+ */
+async function getSteamLibraryPaths() {
+  const os = platform();
+  const home = homedir();
+  const paths = [];
+
+  // Known default Steam install locations to find the vdf
+  const steamRoots = [];
+  if (os === "win32") {
+    steamRoots.push(
+      "C:/Program Files (x86)/Steam",
+      "C:/Program Files/Steam",
+    );
+  } else if (os === "darwin") {
+    steamRoots.push(join(home, "Library/Application Support/Steam"));
+  } else {
+    steamRoots.push(
+      join(home, ".steam/steam"),
+      join(home, ".local/share/Steam"),
+    );
+  }
+
+  for (const root of steamRoots) {
+    const vdfPath = join(root, "steamapps", "libraryfolders.vdf");
+    try {
+      const content = await readFile(vdfPath, "utf-8");
+      // Parse "path" values from the VDF file (simple regex — VDF is not JSON)
+      const pathRegex = /"path"\s+"([^"]+)"/g;
+      let match;
+      while ((match = pathRegex.exec(content)) !== null) {
+        const libPath = match[1].replace(/\\\\/g, "/");
+        const commonPath = join(libPath, "steamapps", "common");
+        if (await dirExists(commonPath)) {
+          paths.push(commonPath);
+        }
+      }
+      if (paths.length > 0) break; // Found a valid vdf, stop looking
+    } catch {
+      // vdf not found here, try next
+    }
+  }
+
+  return paths;
+}
+
+/**
+ * Parse Epic Games launcher manifests to find actual install locations.
+ * These .item files are JSON with an InstallLocation field.
+ */
+async function getEpicInstallPaths() {
+  const os = platform();
+  const paths = [];
+
+  const manifestDirs = [];
+  if (os === "win32") {
+    manifestDirs.push("C:/ProgramData/Epic/EpicGamesLauncher/Data/Manifests");
+  } else if (os === "darwin") {
+    const home = homedir();
+    manifestDirs.push(join(home, "Library/Application Support/Epic/EpicGamesLauncher/Data/Manifests"));
+  }
+
+  for (const manifestDir of manifestDirs) {
+    if (!(await dirExists(manifestDir))) continue;
+    try {
+      const entries = await readdir(manifestDir);
+      for (const entry of entries) {
+        if (!entry.endsWith(".item")) continue;
+        try {
+          const content = await readFile(join(manifestDir, entry), "utf-8");
+          const data = JSON.parse(content);
+          if (data.InstallLocation && data.bIsApplication !== false) {
+            const installPath = data.InstallLocation.replace(/\\\\/g, "/").replace(/\\/g, "/");
+            if (await dirExists(installPath)) {
+              paths.push({ path: installPath, name: data.DisplayName || null });
+            }
+          }
+        } catch { /* skip malformed manifests */ }
+      }
+    } catch { /* skip inaccessible dirs */ }
+  }
+
+  return paths;
+}
+
+/**
+ * Find Epic Games install directories by scanning drives (fallback)
+ * and parsing launcher manifests (primary).
+ */
+async function getEpicGamesPaths() {
+  const os = platform();
+  const home = homedir();
+  const paths = [];
+
+  // Primary: parse manifests for exact install locations
+  const epicInstalls = await getEpicInstallPaths();
+  // These are individual game paths, not parent dirs — we'll handle them separately
+  // For now return parent dirs found by scanning
+
+  if (os === "win32") {
+    const drives = await getWindowsDrives();
+    const epicDirNames = [
+      "Epic Games",
+      "Program Files/Epic Games",
+      "Program Files (x86)/Epic Games",
+      "Games/EpicGames",
+      "Games/Epic Games",
+    ];
+
+    for (const drive of drives) {
+      for (const dirName of epicDirNames) {
+        const fullPath = `${drive}/${dirName}`;
+        if (await dirExists(fullPath)) {
+          paths.push(fullPath);
+        }
+      }
+    }
+  } else if (os === "darwin") {
+    const macPaths = [
+      "/Applications/Epic Games",
+      join(home, "Library/Application Support/Epic"),
+    ];
+    for (const p of macPaths) {
+      if (await dirExists(p)) paths.push(p);
+    }
+  }
+
+  return { parentDirs: paths, individualGames: epicInstalls };
+}
+
+/**
+ * Get all game sources.
+ * Returns { parentDirs: string[], individualGames: {path, name}[] }
+ */
+async function getGameSources() {
+  const os = platform();
+  const home = homedir();
+  const parentDirs = [];
+  const individualGames = [];
+
+  // Steam libraries (from config file)
+  const steamPaths = await getSteamLibraryPaths();
+  parentDirs.push(...steamPaths);
+
+  // Epic Games (manifests + scanned dirs)
+  const epic = await getEpicGamesPaths();
+  parentDirs.push(...epic.parentDirs);
+  individualGames.push(...epic.individualGames);
+
+  // Additional common locations
+  if (os === "win32") {
+    const drives = await getWindowsDrives();
+    for (const drive of drives) {
+      for (const dir of ["Games", "SteamLibrary/steamapps/common"]) {
+        const fullPath = `${drive}/${dir}`;
+        if (await dirExists(fullPath)) {
+          parentDirs.push(fullPath);
+        }
+      }
+    }
+    const homeGames = join(home, "Games");
+    if (await dirExists(homeGames)) parentDirs.push(homeGames);
+  } else if (os === "darwin") {
+    for (const d of ["/Applications/Games", join(home, "Games")]) {
+      if (await dirExists(d)) parentDirs.push(d);
+    }
+  } else {
+    for (const d of [join(home, "Games"), join(home, ".local/share/lutris/games")]) {
+      if (await dirExists(d)) parentDirs.push(d);
+    }
+  }
+
+  // Deduplicate parent dirs
+  const seen = new Set();
+  const dedupedDirs = parentDirs.filter((d) => {
+    const n = d.replace(/\\/g, "/").toLowerCase();
+    if (seen.has(n)) return false;
+    seen.add(n);
+    return true;
+  });
+
+  // Deduplicate individual games (by path, avoid overlap with parent dirs)
+  const dedupedGames = individualGames.filter((g) => {
+    const n = g.path.replace(/\\/g, "/").toLowerCase();
+    // Skip if this game's parent is already in parentDirs
+    for (const pd of dedupedDirs) {
+      const pdn = pd.replace(/\\/g, "/").toLowerCase();
+      if (n.startsWith(pdn + "/") || n.startsWith(pdn + "\\")) return false;
+    }
+    if (seen.has(n)) return false;
+    seen.add(n);
+    return true;
+  });
+
+  return { parentDirs: dedupedDirs, individualGames: dedupedGames };
+}
+
+/**
+ * Recursively find audio files in a directory.
+ */
+async function findAudioFiles(dir, depth = 0, results = [], packedCount = { n: 0 }) {
+  if (depth > MAX_DEPTH || results.length >= MAX_FILES) return results;
+
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (results.length >= MAX_FILES) break;
+
+      const fullPath = join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        const lower = entry.name.toLowerCase();
+        if (["__pycache__", "node_modules", ".git", "shader", "texture"].some(s => lower.includes(s))) {
+          continue;
+        }
+        await findAudioFiles(fullPath, depth + 1, results, packedCount);
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name).toLowerCase();
+        if (AUDIO_EXTENSIONS.has(ext)) {
+          results.push({ path: fullPath, name: entry.name, dir });
+        } else if (PACKED_EXTENSIONS.has(ext)) {
+          packedCount.n++;
+        }
+      }
+    }
+  } catch { /* skip */ }
+
+  return results;
+}
+
+/**
+ * Scan for installed games and their sound files.
+ * Returns a map of game name -> audio files.
+ */
+const SKIP_DIRS = new Set([
+  "launcher", "directxredist", "steamworks shared",
+  "steam controller configs", "epic online services",
+]);
+
+async function scanGameDir(gamePath, gameName, games, onProgress) {
+  if (onProgress) onProgress({ phase: "scanning", game: gameName });
+  await tick();
+
+  const packedCount = { n: 0 };
+  let audioFiles = await findAudioFiles(gamePath, 0, [], packedCount);
+
+  const seen = new Set();
+  audioFiles = audioFiles.filter((f) => {
+    if (seen.has(f.path)) return false;
+    seen.add(f.path);
+    return true;
+  });
+
+  games.set(gameName, {
+    path: gamePath,
+    files: audioFiles.slice(0, 50),
+    packedAudioCount: packedCount.n,
+  });
+}
+
+export async function scanForGames(onProgress, onGameFound) {
+  const { parentDirs, individualGames } = await getGameSources();
+  const games = new Map();
+
+  const allDirs = [...parentDirs, ...individualGames.map((g) => `${g.path} (Epic)`)];
+  if (onProgress) onProgress({ phase: "dirs", dirs: allDirs });
+
+  function emitGame(name, data) {
+    if (onGameFound) {
+      onGameFound({
+        name,
+        path: data.path,
+        fileCount: data.files.length,
+        files: data.files,
+        hasAudio: data.files.length > 0,
+        packedAudioCount: data.packedAudioCount || 0,
+        canExtract: data.packedAudioCount > 0,
+      });
+    }
+  }
+
+  // Scan parent directories (Steam libraries, Epic Games folders, etc.)
+  for (const baseDir of parentDirs) {
+    try {
+      const entries = await readdir(baseDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (SKIP_DIRS.has(entry.name.toLowerCase())) continue;
+
+        await scanGameDir(join(baseDir, entry.name), entry.name, games, onProgress);
+        emitGame(entry.name, games.get(entry.name));
+      }
+    } catch {
+      // Skip inaccessible dirs
+    }
+  }
+
+  // Scan individual game install paths (from Epic manifests, etc.)
+  for (const { path: gamePath, name: displayName } of individualGames) {
+    const gameName = displayName || gamePath.split(/[\\/]/).pop();
+    if (games.has(gameName)) continue; // Already found via parent dir scan
+    await scanGameDir(gamePath, gameName, games, onProgress);
+    emitGame(gameName, games.get(gameName));
+  }
+
+  return games;
+}
+
+/**
+ * Get a flat list of all found game directories.
+ */
+export async function getAvailableGames(onProgress, onGameFound) {
+  const games = await scanForGames(onProgress, onGameFound);
+  return Array.from(games.entries())
+    .map(([name, data]) => ({
+      name,
+      path: data.path,
+      fileCount: data.files.length,
+      files: data.files,
+      hasAudio: data.files.length > 0,
+      packedAudioCount: data.packedAudioCount || 0,
+      canExtract: data.packedAudioCount > 0,
+    }))
+    // Games with audio first, then extractable, then others
+    .sort((a, b) => {
+      if (a.hasAudio !== b.hasAudio) return a.hasAudio ? -1 : 1;
+      if (a.canExtract !== b.canExtract) return a.canExtract ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+}