spotifify 0.1.1

package/src/tui/index.ts

@@ -0,0 +1,32 @@
+import { render } from "ink";
+import { createElement } from "react";
+import type { Matcher } from "../match/matcher.ts";
+import type { Repo } from "../state/repo.ts";
+import { App } from "./App.tsx";
+import { loadQueue } from "./model.ts";
+
+export interface ReviewDeps {
+  repo: Repo;
+  matcher: Matcher;
+  market: string;
+}
+
+/** Runs the interactive review; resolves when the user quits. Every decision is already persisted by then. */
+export async function runReviewTui(deps: ReviewDeps): Promise<{ decided: number }> {
+  const initialQueues = { review: loadQueue(deps.repo, "review"), local: loadQueue(deps.repo, "local") };
+  let decided = 0;
+  const app = render(
+    createElement(App, {
+      repo: deps.repo,
+      matcher: deps.matcher,
+      market: deps.market,
+      initialQueues,
+      onExit: (n: number) => {
+        decided = n;
+      },
+    }),
+  );
+  // Ink wires its exit resolver lazily: waitUntilExit() must be pending before exit() runs, i.e. before any key arrives.
+  await app.waitUntilExit();
+  return { decided };
+}

package/src/tui/model.ts

@@ -0,0 +1,54 @@
+import type { MatchRow } from "../match/types.ts";
+import type { Repo, SourceTrackRow } from "../state/repo.ts";
+
+/** Which queue is on screen: `review` = needs a human; `local` = auto-decided unmatched, still pickable. */
+export type Tab = "review" | "local";
+
+export const TABS: readonly Tab[] = ["review", "local"];
+
+export interface ReviewItem {
+  match: MatchRow;
+  track: SourceTrackRow;
+  playlists: string[];
+}
+
+export type Queues = Record<Tab, ReviewItem[]>;
+
+/** Load one tab's queue; keys without a representative source track are dropped. */
+export function loadQueue(repo: Repo, tab: Tab): ReviewItem[] {
+  const matches = repo.listMatches(tab);
+  const tracks = repo.representativeTracks(matches.map((m) => m.canonicalKey));
+  const items: ReviewItem[] = [];
+  for (const match of matches) {
+    const track = tracks.get(match.canonicalKey);
+    if (!track) continue;
+    items.push({ match, track, playlists: repo.playlistNamesForKey(match.canonicalKey) });
+  }
+  return items;
+}
+
+/** `m:ss`; `--:--` when unknown. */
+export function fmtDuration(ms: number | undefined): string {
+  if (ms === undefined) return "--:--";
+  const s = Math.round(ms / 1000);
+  return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+}
+
+/** Signed whole-second delta between candidate and source, e.g. `+3s`; empty when the source duration is unknown. */
+export function fmtDelta(candidateMs: number, sourceMs: number | undefined): string {
+  if (sourceMs === undefined) return "";
+  const d = Math.round((candidateMs - sourceMs) / 1000);
+  if (d === 0) return "±0s";
+  return `${d > 0 ? "+" : "-"}${Math.abs(d)}s`;
+}
+
+export function scoreColor(score: number): "green" | "yellow" | "red" {
+  if (score >= 0.85) return "green";
+  if (score >= 0.6) return "yellow";
+  return "red";
+}
+
+export function sourceOrigin(track: SourceTrackRow): string {
+  if (track.kind === "netease") return `netease  id ${track.externalId}`;
+  return `local  ${track.file?.path ?? track.externalId}`;
+}

package/src/util/bin.ts

@@ -0,0 +1,12 @@
+/** Probe an external binary by running it with `args`; returns the first output line or null. */
+export async function probeBinary(cmd: string, args: string[]): Promise<string | null> {
+  try {
+    const proc = Bun.spawn([cmd, ...args], { stdout: "pipe", stderr: "pipe", stdin: "ignore" });
+    const [out, err] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
+    await proc.exited;
+    const line = (out || err).split(/\r?\n/, 1)[0]?.trim();
+    return line || `${cmd} (exit ${proc.exitCode})`;
+  } catch {
+    return null;
+  }
+}

package/src/util/clipboard.ts

@@ -0,0 +1,13 @@
+/** Copies text to the system clipboard; returns false when no clipboard command is available. */
+export async function copyToClipboard(text: string): Promise<boolean> {
+  const cmd =
+    process.platform === "win32" ? ["clip"] : process.platform === "darwin" ? ["pbcopy"] : ["xclip", "-selection", "clipboard"];
+  try {
+    const proc = Bun.spawn(cmd, { stdin: "pipe", stdout: "ignore", stderr: "ignore" });
+    proc.stdin.write(text);
+    proc.stdin.end();
+    return (await proc.exited) === 0;
+  } catch {
+    return false;
+  }
+}

package/src/util/fs.ts

@@ -0,0 +1,18 @@
+import { createReadStream } from "node:fs";
+
+/** Replace characters Windows/NTFS rejects and trim trailing dots/spaces. */
+export function sanitizeFilename(name: string, max = 150): string {
+  const cleaned = name
+    .replace(/[<>:"/\\|?*\u0000-\u001f]/g, "_")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/[. ]+$/, "");
+  return (cleaned || "untitled").slice(0, max);
+}
+
+/** blake2b256 hex digest of a file, streamed. */
+export async function hashFile(path: string): Promise<string> {
+  const hasher = new Bun.CryptoHasher("blake2b256");
+  for await (const chunk of createReadStream(path, { highWaterMark: 1 << 20 })) hasher.update(chunk as Buffer);
+  return hasher.digest("hex");
+}

package/src/util/lock.ts

@@ -0,0 +1,38 @@
+import { closeSync, openSync, readFileSync, rmSync, writeSync } from "node:fs";
+
+export class LockHeldError extends Error {
+  constructor(readonly pid: number) {
+    super(`another sync is running (pid ${pid})`);
+    this.name = "LockHeldError";
+  }
+}
+
+/**
+ * Acquire a pid lock file. A lock whose pid is no longer alive is treated as stale and taken over.
+ * Returns a release function; callers must invoke it in `finally`.
+ */
+export function acquireLock(path: string): () => void {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = openSync(path, "wx");
+      writeSync(fd, String(process.pid));
+      closeSync(fd);
+      return () => rmSync(path, { force: true });
+    } catch (e) {
+      if (!(e instanceof Error) || !("code" in e) || e.code !== "EEXIST") throw e;
+      const pid = Number.parseInt(readFileSync(path, "utf-8").trim(), 10);
+      if (Number.isInteger(pid) && pid !== process.pid && isAlive(pid)) throw new LockHeldError(pid);
+      rmSync(path, { force: true }); // stale: owner died without cleanup
+    }
+  }
+  throw new Error(`could not acquire lock ${path}`);
+}
+
+function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e instanceof Error && "code" in e && e.code === "EPERM";
+  }
+}

package/src/util/log.ts

@@ -0,0 +1,31 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+export type Level = "debug" | "info" | "warn" | "error";
+
+const ORDER: Record<Level, number> = { debug: 0, info: 1, warn: 2, error: 3 };
+
+let threshold: Level = "info";
+let filePath: string | null = null;
+
+export function configureLog(opts: { level?: Level; file?: string }): void {
+  if (opts.level) threshold = opts.level;
+  if (opts.file) {
+    mkdirSync(dirname(opts.file), { recursive: true });
+    filePath = opts.file;
+  }
+}
+
+function emit(level: Level, msg: string, data?: unknown): void {
+  if (ORDER[level] < ORDER[threshold]) return;
+  const line = `${new Date().toISOString()} ${level.toUpperCase().padEnd(5)} ${msg}${data === undefined ? "" : " " + JSON.stringify(data)}`;
+  (level === "error" || level === "warn" ? console.error : console.log)(line);
+  if (filePath) appendFileSync(filePath, line + "\n");
+}
+
+export const log = {
+  debug: (msg: string, data?: unknown) => emit("debug", msg, data),
+  info: (msg: string, data?: unknown) => emit("info", msg, data),
+  warn: (msg: string, data?: unknown) => emit("warn", msg, data),
+  error: (msg: string, data?: unknown) => emit("error", msg, data),
+};

package/src/util/open.ts

@@ -0,0 +1,22 @@
+import { log } from "./log.ts";
+
+/**
+ * Open a URL or file with the OS default handler, detached.
+ * Windows: `cmd /c start` would parse `&` in query strings as a command separator and mangle URLs;
+ * rundll32's protocol handler passes the argument through verbatim.
+ */
+export function openExternal(target: string): boolean {
+  const cmd =
+    process.platform === "win32"
+      ? ["rundll32", "url.dll,FileProtocolHandler", target]
+      : process.platform === "darwin"
+        ? ["open", target]
+        : ["xdg-open", target];
+  try {
+    Bun.spawn(cmd, { stdout: "ignore", stderr: "ignore", stdin: "ignore" }).unref();
+    return true;
+  } catch (e) {
+    log.warn("could not open externally", { target, error: String(e) });
+    return false;
+  }
+}

package/src/util/retry.ts

@@ -0,0 +1,49 @@
+export function sleep(ms: number): Promise<void> {
+  const { promise, resolve } = Promise.withResolvers<void>();
+  setTimeout(resolve, ms);
+  return promise;
+}
+
+export class RetryableError extends Error {
+  constructor(
+    message: string,
+    readonly retryAfterMs?: number,
+  ) {
+    super(message);
+    this.name = "RetryableError";
+  }
+}
+
+/** Retries `fn` on RetryableError with exponential backoff, honoring `retryAfterMs` when given. */
+export async function withRetry<T>(fn: () => Promise<T>, opts: { attempts?: number; baseMs?: number } = {}): Promise<T> {
+  const attempts = opts.attempts ?? 4;
+  const baseMs = opts.baseMs ?? 500;
+  for (let i = 0; ; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (!(e instanceof RetryableError) || i + 1 >= attempts) throw e;
+      await sleep(e.retryAfterMs ?? baseMs * 2 ** i);
+    }
+  }
+}
+
+/** Runs `worker` over `items` with at most `limit` in flight; results keep input order. */
+export async function mapLimit<T, R>(items: readonly T[], limit: number, worker: (item: T, index: number) => Promise<R>): Promise<R[]> {
+  const results = new Array<R>(items.length);
+  let next = 0;
+  const lanes = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await worker(items[i]!, i);
+    }
+  });
+  await Promise.all(lanes);
+  return results;
+}
+
+export function chunk<T>(arr: readonly T[], size: number): T[][] {
+  const out: T[][] = [];
+  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+  return out;
+}