reelsort 0.1.1 → 0.2.0

package/dist/cli.js

@@ -0,0 +1,2124 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/program.ts
+var import_termkit19 = require("termkit");
+
+// src/actions/add.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_termkit2 = require("termkit");
+
+// src/config.ts
+var import_fs = require("fs");
+var import_os = require("os");
+var import_path = require("path");
+var CONFIG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".config", "reelsort");
+var CONFIG_PATH = (0, import_path.join)(CONFIG_DIR, "config.json");
+var getConfig = () => {
+  if (!(0, import_fs.existsSync)(CONFIG_PATH)) return { sources: [], dest: {} };
+  return JSON.parse((0, import_fs.readFileSync)(CONFIG_PATH, "utf-8"));
+};
+var saveConfig = (config) => {
+  if (!(0, import_fs.existsSync)(CONFIG_DIR)) (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
+  (0, import_fs.writeFileSync)(CONFIG_PATH, JSON.stringify(config, null, 2));
+};
+
+// src/db.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+var import_fs2 = require("fs");
+var import_os2 = require("os");
+var import_path2 = require("path");
+var DB_DIR = (0, import_path2.join)((0, import_os2.homedir)(), ".config", "reelsort");
+var DB_PATH = (0, import_path2.join)(DB_DIR, "reelsort.db");
+var _db = null;
+var db = () => {
+  if (_db) return _db;
+  if (!(0, import_fs2.existsSync)(DB_DIR)) (0, import_fs2.mkdirSync)(DB_DIR, { recursive: true });
+  _db = new import_better_sqlite3.default(DB_PATH);
+  _db.exec(`
+    CREATE TABLE IF NOT EXISTS shows (
+      id      INTEGER PRIMARY KEY AUTOINCREMENT,
+      path    TEXT    NOT NULL UNIQUE,
+      tmdbId  INTEGER,
+      title   TEXT,
+      ended   INTEGER NOT NULL DEFAULT 0,
+      addedAt DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE TABLE IF NOT EXISTS renameHistory (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      sessionId   TEXT    NOT NULL,
+      oldPath     TEXT    NOT NULL,
+      newPath     TEXT    NOT NULL,
+      renamedAt   DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE TABLE IF NOT EXISTS mediaInfo (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      filePath    TEXT    NOT NULL UNIQUE,
+      codec       TEXT,
+      resolution  TEXT,
+      width       INTEGER,
+      height      INTEGER,
+      duration    REAL,
+      probedAt    DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE TABLE IF NOT EXISTS imports (
+      id               INTEGER PRIMARY KEY AUTOINCREMENT,
+      sessionId        TEXT    NOT NULL,
+      sourcePath       TEXT    NOT NULL,
+      destinationPath  TEXT    NOT NULL,
+      mode             TEXT    NOT NULL,
+      tmdbId           INTEGER,
+      importedAt       DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+  try {
+    _db.exec("ALTER TABLE shows ADD COLUMN title TEXT");
+  } catch {
+  }
+  return _db;
+};
+var recordRename = (sessionId, oldPath, newPath) => {
+  db().prepare("INSERT INTO renameHistory (sessionId, oldPath, newPath) VALUES (?, ?, ?)").run(sessionId, oldPath, newPath);
+};
+var getLastSession = () => {
+  const last = db().prepare("SELECT sessionId FROM renameHistory ORDER BY id DESC LIMIT 1").get();
+  if (!last) return [];
+  return db().prepare("SELECT * FROM renameHistory WHERE sessionId = ? ORDER BY id DESC").all(last.sessionId);
+};
+var deleteSession = (sessionId) => {
+  db().prepare("DELETE FROM renameHistory WHERE sessionId = ?").run(sessionId);
+};
+var recordImport = (sessionId, sourcePath, destPath, mode, tmdbId) => {
+  db().prepare("INSERT INTO imports (sessionId, sourcePath, destinationPath, mode, tmdbId) VALUES (?, ?, ?, ?, ?)").run(sessionId, sourcePath, destPath, mode, tmdbId ?? null);
+};
+var getMediaInfo = (filePath) => {
+  return db().prepare("SELECT * FROM mediaInfo WHERE filePath = ?").get(filePath);
+};
+var upsertMediaInfo = (filePath, codec, resolution, width, height, duration) => {
+  db().prepare(
+    `INSERT INTO mediaInfo (filePath, codec, resolution, width, height, duration, probedAt)
+              VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+              ON CONFLICT(filePath) DO UPDATE SET
+                codec = excluded.codec, resolution = excluded.resolution,
+                width = excluded.width, height = excluded.height,
+                duration = excluded.duration, probedAt = excluded.probedAt`
+  ).run(filePath, codec, resolution, width, height, duration);
+};
+var getImportByDest = (destPath) => {
+  return db().prepare("SELECT * FROM imports WHERE destinationPath = ? LIMIT 1").get(destPath);
+};
+var rowToShow = (row) => ({
+  ...row,
+  ended: row.ended === 1
+});
+var getShow = (path) => {
+  const row = db().prepare("SELECT * FROM shows WHERE path = ?").get(path);
+  return row ? rowToShow(row) : null;
+};
+var getShows = () => db().prepare("SELECT * FROM shows ORDER BY path ASC").all().map(rowToShow);
+var upsertShow = (path, tmdbId, title) => {
+  db().prepare(
+    `
+      INSERT INTO shows (path, tmdbId, title) VALUES (?, ?, ?)
+      ON CONFLICT(path) DO UPDATE SET
+        tmdbId = COALESCE(excluded.tmdbId, tmdbId),
+        title  = COALESCE(excluded.title,  title)
+    `
+  ).run(path, tmdbId, title ?? null);
+};
+var getShowByTitle = (title) => {
+  const t = title.toLowerCase();
+  return getShows().find((s) => {
+    if (s.title?.toLowerCase() === t) return true;
+    const folderTitle = (s.path.split("/").pop() ?? "").replace(/\s*\(\d{4}\).*$/, "").trim().toLowerCase();
+    return folderTitle === t;
+  }) ?? null;
+};
+var setShowEnded = (path, ended2) => {
+  db().prepare("UPDATE shows SET ended = ? WHERE path = ?").run(ended2 ? 1 : 0, path);
+};
+var getTmdbIdForShow = (showPath) => {
+  const show = getShow(showPath);
+  if (show?.tmdbId) return show.tmdbId;
+  const row = db().prepare(`SELECT tmdbId FROM imports WHERE destinationPath LIKE ? AND tmdbId IS NOT NULL LIMIT 1`).get(`${showPath}%`);
+  return row?.tmdbId ?? null;
+};
+var getCleanableImports = () => {
+  return db().prepare(`SELECT * FROM imports WHERE mode IN ('hardlink', 'copy') ORDER BY importedAt ASC`).all();
+};
+var deleteImport = (id) => {
+  db().prepare("DELETE FROM imports WHERE id = ?").run(id);
+};
+var getImportHistory = (limit = 10) => {
+  const sessionIds = db().prepare("SELECT sessionId FROM imports GROUP BY sessionId ORDER BY MAX(id) DESC LIMIT ?").all(limit);
+  return sessionIds.map(({ sessionId }) => ({
+    sessionId,
+    records: db().prepare("SELECT * FROM imports WHERE sessionId = ? ORDER BY id ASC").all(sessionId)
+  }));
+};
+var getHistory = (limit = 10) => {
+  const sessionIds = db().prepare("SELECT sessionId FROM renameHistory GROUP BY sessionId ORDER BY MAX(id) DESC LIMIT ?").all(limit);
+  return sessionIds.map(({ sessionId }) => ({
+    sessionId,
+    records: db().prepare("SELECT * FROM renameHistory WHERE sessionId = ? ORDER BY id DESC").all(sessionId)
+  }));
+};
+
+// src/helpers/formatName.ts
+var DEFAULT_MOVIE_FORMAT = "{title} ({year})";
+var formatMovieName = (template, title, year, edition) => {
+  const editionTag = edition ? ` {edition-${edition}}` : "";
+  let result = template.replace("{title}", title).replace("{edition}", editionTag);
+  if (year) {
+    result = result.replace("{year}", year.toString());
+  } else {
+    result = result.replace(/\s*[([{]\{year\}[)\]}]/g, "").replace("{year}", "");
+  }
+  return result.replace(/\s+/g, " ").trim();
+};
+
+// src/helpers/hyperlink.ts
+var hyperlink = (url, text) => `\x1B]8;;${url}\x1B\\${text}\x1B]8;;\x1B\\`;
+
+// src/helpers/tmdb.ts
+var BASE = "https://api.themoviedb.org/3";
+var TMDB_WEB = "https://www.themoviedb.org";
+var searchMovie = async (title, year, apiKey) => {
+  const url = new URL(`${BASE}/search/movie`);
+  url.searchParams.set("api_key", apiKey);
+  url.searchParams.set("query", title);
+  if (year) url.searchParams.set("year", String(year));
+  try {
+    const res = await fetch(url.toString());
+    if (!res.ok) return null;
+    const data = await res.json();
+    const first = data.results[0];
+    if (!first) return null;
+    return {
+      id: first.id,
+      title: first.title,
+      year: first.release_date ? parseInt(first.release_date.slice(0, 4)) : void 0,
+      url: `${TMDB_WEB}/movie/${first.id}`
+    };
+  } catch {
+    return null;
+  }
+};
+var getEpisodeName = async (seriesId, season, episode, apiKey) => {
+  const url = new URL(`${BASE}/tv/${seriesId}/season/${season}/episode/${episode}`);
+  url.searchParams.set("api_key", apiKey);
+  try {
+    const res = await fetch(url.toString());
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.name ?? null;
+  } catch {
+    return null;
+  }
+};
+var getSeasonEpisodes = async (seriesId, season, apiKey) => {
+  const url = new URL(`${BASE}/tv/${seriesId}/season/${season}`);
+  url.searchParams.set("api_key", apiKey);
+  try {
+    const res = await fetch(url.toString());
+    if (!res.ok) return [];
+    const data = await res.json();
+    return (data.episodes ?? []).map((e) => ({
+      episode: e.episode_number,
+      name: e.name,
+      airDate: e.air_date || void 0
+    }));
+  } catch {
+    return [];
+  }
+};
+var searchTv = async (title, apiKey) => {
+  const url = new URL(`${BASE}/search/tv`);
+  url.searchParams.set("api_key", apiKey);
+  url.searchParams.set("query", title);
+  try {
+    const res = await fetch(url.toString());
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.results.slice(0, 5).map((r) => ({
+      id: r.id,
+      title: r.name,
+      year: r.first_air_date ? parseInt(r.first_air_date.slice(0, 4)) : void 0,
+      overview: r.overview || void 0,
+      url: `${TMDB_WEB}/tv/${r.id}`
+    }));
+  } catch {
+    return [];
+  }
+};
+
+// src/refs/spinner.ts
+var import_termkit = require("termkit");
+var Spinner = class {
+  spinner;
+  constructor() {
+    this.spinner = new import_termkit.Spinner();
+  }
+  get text() {
+    return this.spinner.text;
+  }
+  set text(t) {
+    this.spinner.text = t;
+  }
+  start(s) {
+    if (s) this.spinner.text = s;
+    this.spinner.start();
+    return this;
+  }
+  info(s) {
+    this.spinner.info(s);
+    return this;
+  }
+  warn(s) {
+    this.spinner.warn(s);
+    return this;
+  }
+  fail(s) {
+    this.spinner.fail(s);
+    return this;
+  }
+  succeed(s) {
+    this.spinner.succeed(s);
+    return this;
+  }
+  stop() {
+    this.spinner.stop();
+    return this;
+  }
+};
+var spinner_default = new Spinner();
+
+// src/actions/add.ts
+var add = async ({ name }) => {
+  const config = getConfig();
+  if (!config.tmdbApiKey) throw new Error("TMDb API key required \u2014 run: reelsort config set tmdb-key <key>");
+  const destRoot = config.dest.tv;
+  if (!destRoot) throw new Error("no TV destination configured \u2014 run: reelsort config set dest tv <dir>");
+  spinner_default.start(`searching TMDb for "${name}"`);
+  const results = await searchTv(name, config.tmdbApiKey);
+  spinner_default.stop();
+  if (results.length === 0) throw new Error(`no TMDb results for "${name}"`);
+  let picked = results.length === 1 ? results[0] : null;
+  if (!picked) {
+    const select = new import_termkit2.Select();
+    const items = results.map((r) => ({
+      label: r.year ? `${r.title} (${r.year})` : r.title,
+      description: [r.overview?.slice(0, 60), hyperlink(r.url, "themoviedb.org")].filter(Boolean).join(" \xB7 "),
+      ...r
+    }));
+    picked = await select.ask(`Results for "${name}":`, items);
+    if (!picked) return;
+  }
+  const movieFormat = config.format?.movie ?? DEFAULT_MOVIE_FORMAT;
+  const folderName = formatMovieName(movieFormat, picked.title, picked.year);
+  const showPath = (0, import_path3.resolve)(destRoot, folderName);
+  (0, import_fs3.mkdirSync)(showPath, { recursive: true });
+  upsertShow(showPath, picked.id, picked.title);
+  spinner_default.start();
+  spinner_default.succeed(`added ${import_termkit2.Color.cyan.encoder(folderName)}`);
+  spinner_default.stop();
+};
+var add_default = add;
+
+// src/actions/clean.ts
+var import_fs4 = require("fs");
+var import_termkit3 = require("termkit");
+var parseOlderThan = (s) => {
+  const match = s.match(/^(\d+)([dhm])$/);
+  if (!match) return null;
+  const n = parseInt(match[1]);
+  const unit = match[2];
+  const ms = unit === "d" ? n * 864e5 : unit === "h" ? n * 36e5 : n * 6e4;
+  return ms;
+};
+var clean = async ({ dryRun, olderThan }) => {
+  spinner_default.start();
+  const imports = getCleanableImports();
+  if (imports.length === 0) {
+    spinner_default.info("nothing to clean");
+    spinner_default.stop();
+    return;
+  }
+  const cutoffMs = olderThan ? parseOlderThan(olderThan) : null;
+  if (olderThan && cutoffMs === null) throw new Error(`invalid --older-than format, expected e.g. 14d, 6h, 30m`);
+  let cleaned = 0, skipped = 0;
+  for (const imp of imports) {
+    if (cutoffMs !== null) {
+      const age = Date.now() - new Date(imp.importedAt).getTime();
+      if (age < cutoffMs) {
+        skipped++;
+        continue;
+      }
+    }
+    if (!(0, import_fs4.existsSync)(imp.sourcePath)) {
+      if (!dryRun) deleteImport(imp.id);
+      continue;
+    }
+    if (dryRun) {
+      spinner_default.succeed(`[dry] would remove ${import_termkit3.Color.blue.encoder(imp.sourcePath)}`);
+      cleaned++;
+      continue;
+    }
+    try {
+      (0, import_fs4.rmSync)(imp.sourcePath, { recursive: true, force: true });
+      deleteImport(imp.id);
+      spinner_default.succeed(`removed ${import_termkit3.Color.blue.encoder(imp.sourcePath)}`);
+      cleaned++;
+    } catch {
+      spinner_default.warn(`locked or inaccessible, skipped: ${import_termkit3.Color.blue.encoder(imp.sourcePath)}`);
+      skipped++;
+    }
+  }
+  spinner_default.succeed(`cleaned ${cleaned} items`);
+  if (skipped) spinner_default.info(`skipped ${skipped} items`);
+  spinner_default.stop();
+};
+var clean_default = clean;
+
+// src/actions/config.ts
+var import_path4 = require("path");
+var import_termkit4 = require("termkit");
+
+// src/helpers/formatEpisode.ts
+var DEFAULT_EPISODE_FORMAT = "{s}x{ee}";
+var DEFAULT_SEASON_FORMAT = "Season {s}";
+var renderEpisode = (format, season, episode, title, name) => {
+  return format.replace(/\{sss\}/g, season.toString().padStart(3, "0")).replace(/\{ss\}/g, season.toString().padStart(2, "0")).replace(/\{s\}/g, season.toString()).replace(/\{eee\}/g, episode.toString().padStart(3, "0")).replace(/\{ee\}/g, episode.toString().padStart(2, "0")).replace(/\{e\}/g, episode.toString()).replace(/\{title\}/g, title ?? "").replace(/\{name\}/g, name ?? "").replace(/\s+/g, " ").trim();
+};
+var formatSeasonFolder = (format, season) => format.replace(/\{sss\}/g, season.toString().padStart(3, "0")).replace(/\{ss\}/g, season.toString().padStart(2, "0")).replace(/\{s\}/g, season.toString()).trim();
+var formatEpisode = (season, episode, format = DEFAULT_EPISODE_FORMAT, double = false, title, name) => {
+  if (double) {
+    const a = renderEpisode(format, season, episode, title, name);
+    const b = renderEpisode(format, season, episode + 1, title, name);
+    return `${a}-${b}`;
+  }
+  return renderEpisode(format, season, episode, title, name);
+};
+
+// src/actions/config.ts
+var DEST_TYPES = ["movie", "tv", "ps3"];
+var sourceAdd = async ({ dir }) => {
+  const resolved = (0, import_path4.resolve)(dir);
+  const config = getConfig();
+  if (config.sources.includes(resolved)) {
+    spinner_default.start();
+    spinner_default.info(`source already configured: ${import_termkit4.Color.blue.encoder(resolved)}`);
+    spinner_default.stop();
+    return;
+  }
+  config.sources.push(resolved);
+  saveConfig(config);
+  spinner_default.start();
+  spinner_default.succeed(`added source: ${import_termkit4.Color.blue.encoder(resolved)}`);
+  spinner_default.stop();
+};
+var sourceRemove = async ({ dir }) => {
+  const resolved = (0, import_path4.resolve)(dir);
+  const config = getConfig();
+  const index = config.sources.indexOf(resolved);
+  if (index === -1) {
+    spinner_default.start();
+    spinner_default.warn(`source not found: ${import_termkit4.Color.blue.encoder(resolved)}`);
+    spinner_default.stop();
+    return;
+  }
+  config.sources.splice(index, 1);
+  saveConfig(config);
+  spinner_default.start();
+  spinner_default.succeed(`removed source: ${import_termkit4.Color.blue.encoder(resolved)}`);
+  spinner_default.stop();
+};
+var destAdd = async ({ type, dir }) => {
+  if (!DEST_TYPES.includes(type)) {
+    throw new Error(`unknown type '${type}', expected: ${DEST_TYPES.join(", ")}`);
+  }
+  const resolved = (0, import_path4.resolve)(dir);
+  const config = getConfig();
+  config.dest[type] = resolved;
+  saveConfig(config);
+  spinner_default.start();
+  spinner_default.succeed(`set ${type} destination: ${import_termkit4.Color.cyan.encoder(resolved)}`);
+  spinner_default.stop();
+};
+var destRemove = async ({ type }) => {
+  if (!DEST_TYPES.includes(type)) {
+    throw new Error(`unknown type '${type}', expected: ${DEST_TYPES.join(", ")}`);
+  }
+  const config = getConfig();
+  if (!config.dest[type]) {
+    spinner_default.start();
+    spinner_default.warn(`no ${type} destination configured`);
+    spinner_default.stop();
+    return;
+  }
+  delete config.dest[type];
+  saveConfig(config);
+  spinner_default.start();
+  spinner_default.succeed(`removed ${type} destination`);
+  spinner_default.stop();
+};
+var configSet = async ({ key, subkey, value }) => {
+  const config = getConfig();
+  if (key === "language") {
+    config.language = subkey;
+    saveConfig(config);
+    spinner_default.start();
+    spinner_default.succeed(`set subtitle language: ${import_termkit4.Color.cyan.encoder(subkey)}`);
+    spinner_default.stop();
+    return;
+  }
+  if (key === "tmdb-key") {
+    config.tmdbApiKey = subkey;
+    saveConfig(config);
+    spinner_default.start();
+    spinner_default.succeed(`set TMDb API key`);
+    spinner_default.stop();
+    return;
+  }
+  if (key === "format") {
+    if (subkey === "episode") {
+      if (!value) throw new Error('missing format string for episode, e.g. "S{ss}E{ee}"');
+      if (!/\{e+\}/.test(value)) throw new Error("episode format must include an episode token: {e}, {ee}, or {eee}");
+      config.format = { ...config.format, episode: value };
+    } else if (subkey === "movie") {
+      if (!value) throw new Error('missing format string for movie, e.g. "{title} ({year})"');
+      if (!value.includes("{title}")) throw new Error("movie format must include {title}");
+      config.format = { ...config.format, movie: value };
+    } else if (subkey === "season") {
+      if (!value) throw new Error('missing format string for season, e.g. "Season {s}"');
+      if (!/\{s+\}/.test(value)) throw new Error("season format must include a season token: {s}, {ss}, or {sss}");
+      config.format = { ...config.format, season: value };
+    } else {
+      throw new Error(`unknown format key '${subkey}', expected: movie, episode, season`);
+    }
+    saveConfig(config);
+    spinner_default.start();
+    spinner_default.succeed(`set ${subkey} format: ${import_termkit4.Color.cyan.encoder(value ?? subkey)}`);
+    spinner_default.stop();
+    return;
+  }
+  throw new Error(`unknown key '${key}', expected: language, tmdb-key, format`);
+};
+var configShow = async () => {
+  const config = getConfig();
+  console.log("\nSources:");
+  if (config.sources.length === 0) {
+    console.log("  (none)");
+  } else {
+    for (const s of config.sources) console.log(`  ${import_termkit4.Color.blue.encoder(s)}`);
+  }
+  console.log("\nDestinations:");
+  const entries = DEST_TYPES.map((t) => ({ type: t, path: config.dest[t] })).filter((e) => e.path);
+  if (entries.length === 0) {
+    console.log("  (none)");
+  } else {
+    for (const { type, path } of entries) {
+      console.log(`  ${type.padEnd(6)}  ${import_termkit4.Color.cyan.encoder(path)}`);
+    }
+  }
+  console.log(`
+Subtitle language: ${import_termkit4.Color.cyan.encoder(config.language ?? "eng (default)")}`);
+  console.log(`TMDb API key:      ${config.tmdbApiKey ? import_termkit4.Color.green.encoder("configured") : import_termkit4.Color.red.encoder("not set")}`);
+  console.log(`Movie format:      ${import_termkit4.Color.cyan.encoder(config.format?.movie ?? DEFAULT_MOVIE_FORMAT + " (default)")}`);
+  console.log(`Episode format:    ${import_termkit4.Color.cyan.encoder(config.format?.episode ?? DEFAULT_EPISODE_FORMAT + " (default)")}`);
+  console.log(`Season folder:     ${import_termkit4.Color.cyan.encoder(config.format?.season ?? DEFAULT_SEASON_FORMAT + " (default)")}`);
+  console.log();
+};
+
+// src/actions/differences.ts
+var import_fs5 = require("fs");
+var import_path5 = require("path");
+var import_termkit5 = require("termkit");
+var differences = async ({ dir1: rawDir1, dir2: rawDir2, only, ignore }) => {
+  let dir1 = rawDir1;
+  let dir2 = rawDir2;
+  spinner_default.text = `checking differences between ${import_termkit5.Color.blue.encoder(dir1)} and ${import_termkit5.Color.blue.encoder(dir2)}`;
+  spinner_default.start();
+  dir1 = (0, import_path5.resolve)(dir1);
+  dir2 = (0, import_path5.resolve)(dir2);
+  if (!(0, import_fs5.existsSync)(dir1)) throw new Error(`dir1 ${dir1} does not exist`);
+  if (!(0, import_fs5.existsSync)(dir2)) throw new Error(`dir2 ${dir2} does not exist`);
+  let list1 = (0, import_fs5.readdirSync)(dir1);
+  let list2 = (0, import_fs5.readdirSync)(dir2);
+  if (only && only.length) {
+    list1 = list1.filter((i) => {
+      for (const o of only) if (i.endsWith(o)) return true;
+      return false;
+    });
+    list2 = list2.filter((i) => {
+      for (const o of only) if (i.endsWith(o)) return true;
+      return false;
+    });
+  }
+  if (ignore && ignore.length) {
+    list1 = list1.filter((i) => {
+      for (const o of ignore) if (i.endsWith(o)) return false;
+      return true;
+    });
+    list2 = list2.filter((i) => {
+      for (const o of ignore) if (i.endsWith(o)) return false;
+      return true;
+    });
+  }
+  const added = [], removed = [];
+  for (const l of list1) {
+    if (list2.includes(l)) {
+      added.push(l);
+    } else {
+      removed.push(l);
+    }
+  }
+  spinner_default.succeed(`checked differences between ${import_termkit5.Color.blue.encoder(dir1)} and ${import_termkit5.Color.blue.encoder(dir2)}`);
+  spinner_default.succeed(`found ${added.length} added files`);
+  spinner_default.succeed(`found ${removed.length} removed files`);
+  spinner_default.stop();
+  for (const i of added) console.log(`${import_termkit5.Color.green.encoder("added")} ${i}`);
+  for (const i of removed) console.log(`${import_termkit5.Color.red.encoder("removed")} ${i}`);
+};
+var differences_default = differences;
+
+// src/actions/ended.ts
+var import_termkit6 = require("termkit");
+var ended = async ({ remove }) => {
+  const shows2 = getShows();
+  const candidates = shows2.filter((s) => remove ? s.ended : !s.ended);
+  if (candidates.length === 0) {
+    spinner_default.start();
+    spinner_default.info(remove ? "no ended shows to restore" : "no active shows to mark as ended");
+    spinner_default.stop();
+    return;
+  }
+  const select = new import_termkit6.Select();
+  const items = candidates.map((s) => ({
+    label: s.path.split("/").pop() ?? s.path,
+    path: s.path
+  }));
+  const prompt = remove ? "Which show should be marked as active?" : "Which show has ended?";
+  const picked = await select.ask(prompt, items);
+  if (!picked) return;
+  setShowEnded(picked.path, !remove);
+  spinner_default.start();
+  if (remove) {
+    spinner_default.succeed(`marked as active: ${import_termkit6.Color.cyan.encoder(picked.label)}`);
+  } else {
+    spinner_default.succeed(`marked as ended: ${import_termkit6.Color.cyan.encoder(picked.label)}`);
+  }
+  spinner_default.stop();
+};
+var ended_default = ended;
+
+// src/actions/history.ts
+var import_path6 = require("path");
+var import_termkit7 = require("termkit");
+var history = async ({ limit, imports }) => {
+  if (imports) {
+    const sessions = getImportHistory(limit ?? 10);
+    if (sessions.length === 0) {
+      console.log("no import history found");
+      return;
+    }
+    for (const session of sessions) {
+      const date = new Date(session.sessionId);
+      const label = isNaN(date.getTime()) ? session.sessionId : date.toLocaleString();
+      console.log(`
+${import_termkit7.Color.yellow.encoder(label)}  (${session.records.length} item${session.records.length !== 1 ? "s" : ""})`);
+      for (const r of session.records) {
+        const src = (0, import_path6.basename)(r.sourcePath);
+        const dest = import_termkit7.Color.cyan.encoder(r.destinationPath);
+        const mode = r.mode !== "move" ? ` ${import_termkit7.Color.blue.encoder(`[${r.mode}]`)}` : "";
+        console.log(`  ${src}  \u2192  ${dest}${mode}`);
+      }
+    }
+  } else {
+    const sessions = getHistory(limit ?? 10);
+    if (sessions.length === 0) {
+      console.log("no history found");
+      return;
+    }
+    for (const session of sessions) {
+      const date = new Date(session.sessionId);
+      const label = isNaN(date.getTime()) ? session.sessionId : date.toLocaleString();
+      const folders = session.records.filter((r) => (0, import_path6.extname)(r.newPath) === "");
+      console.log(`
+${import_termkit7.Color.yellow.encoder(label)}  (${folders.length} item${folders.length !== 1 ? "s" : ""})`);
+      for (const r of folders) {
+        const oldName = (0, import_path6.basename)(r.oldPath);
+        const newName = (0, import_path6.basename)(r.newPath);
+        console.log(`  ${import_termkit7.Color.blue.encoder(oldName)}  \u2192  ${import_termkit7.Color.cyan.encoder(newName)}`);
+      }
+    }
+  }
+  console.log();
+};
+var history_default = history;
+
+// src/actions/link.ts
+var import_fs6 = require("fs");
+var import_path7 = require("path");
+var import_termkit8 = require("termkit");
+var parseShowTitle = (folderName) => {
+  const withoutYear = folderName.replace(/\s*\(\d{4}\)\s*$/, "").trim();
+  return withoutYear || folderName;
+};
+var subdirs = (dir) => (0, import_fs6.readdirSync)(dir).filter((f) => {
+  try {
+    return (0, import_fs6.lstatSync)((0, import_path7.resolve)(dir, f)).isDirectory();
+  } catch {
+    return false;
+  }
+});
+var link = async ({ force }) => {
+  const config = getConfig();
+  if (!config.tmdbApiKey) throw new Error("TMDb API key required \u2014 run: reelsort config set tmdb-key <key>");
+  const destRoot = config.dest.tv;
+  if (!destRoot) throw new Error("no TV destination configured \u2014 run: reelsort config set dest tv <dir>");
+  if (!(0, import_fs6.existsSync)(destRoot)) throw new Error(`TV destination not found: ${destRoot}`);
+  const shows2 = subdirs(destRoot);
+  let linked = 0, skipped = 0, notFound = 0;
+  for (const show of shows2) {
+    const showPath = (0, import_path7.resolve)(destRoot, show);
+    const existing = getShow(showPath);
+    if (!force && existing?.tmdbId) {
+      skipped++;
+      continue;
+    }
+    spinner_default.start(`linking ${import_termkit8.Color.blue.encoder(show)}`);
+    const title = parseShowTitle(show);
+    const results = await searchTv(title, config.tmdbApiKey);
+    if (results.length === 0) {
+      spinner_default.warn(`not found in TMDb: ${show}`);
+      notFound++;
+      continue;
+    }
+    if (results.length === 1) {
+      upsertShow(showPath, results[0].id, results[0].title);
+      spinner_default.succeed(`${show} \u2192 ${import_termkit8.Color.cyan.encoder(results[0].title)} (${results[0].year})`);
+      linked++;
+      continue;
+    }
+    spinner_default.stop();
+    const select = new import_termkit8.Select();
+    const items = results.map((r) => ({
+      label: r.year ? `${r.title} (${r.year})` : r.title,
+      description: [r.overview?.slice(0, 60), hyperlink(r.url, "themoviedb.org")].filter(Boolean).join(" \xB7 "),
+      ...r
+    }));
+    const picked = await select.ask(`Multiple shows found for "${show}":`, items);
+    spinner_default.start();
+    if (picked) {
+      upsertShow(showPath, picked.id, picked.title);
+      spinner_default.succeed(`${show} \u2192 ${import_termkit8.Color.cyan.encoder(picked.title)} (${picked.year})`);
+      linked++;
+    } else {
+      spinner_default.info(`skipped: ${show}`);
+      skipped++;
+    }
+  }
+  spinner_default.succeed(`linked ${linked} show${linked !== 1 ? "s" : ""}`);
+  if (notFound) spinner_default.warn(`not found in TMDb: ${notFound}`);
+  if (skipped) spinner_default.info(`skipped ${skipped} (already linked \u2014 use --force to re-link)`);
+  spinner_default.stop();
+};
+var link_default = link;
+
+// src/actions/list.ts
+var import_fs8 = require("fs");
+var import_path9 = require("path");
+var import_termkit9 = require("termkit");
+
+// src/helpers/dirSize.ts
+var import_fs7 = require("fs");
+var import_path8 = require("path");
+var dirSize = (dir) => {
+  let total = 0;
+  try {
+    for (const entry of (0, import_fs7.readdirSync)(dir, { withFileTypes: true })) {
+      const full = (0, import_path8.resolve)(dir, entry.name);
+      if (entry.isDirectory()) {
+        total += dirSize(full);
+      } else if (entry.isFile()) {
+        try {
+          total += (0, import_fs7.statSync)(full).size;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return total;
+};
+var formatSize = (bytes) => {
+  if (bytes >= 1099511627776) return `${(bytes / 1099511627776).toFixed(1)} TB`;
+  if (bytes >= 1073741824) return `${(bytes / 1073741824).toFixed(1)} GB`;
+  if (bytes >= 1048576) return `${(bytes / 1048576).toFixed(1)} MB`;
+  return `${(bytes / 1024).toFixed(1)} KB`;
+};
+
+// src/helpers/parseQuality.ts
+var RESOLUTION_MAP = {
+  "480p": "480p",
+  "576p": "576p",
+  "720p": "720p",
+  "1080p": "1080p",
+  "2160p": "2160p",
+  "4k": "2160p",
+  uhd: "2160p",
+  "8k": "8K"
+};
+var CODEC_MAP = {
+  x264: "x264",
+  h264: "x264",
+  avc: "x264",
+  x265: "x265",
+  h265: "x265",
+  hevc: "x265",
+  xvid: "XviD",
+  divx: "DivX"
+};
+var parseQuality = (filename) => {
+  const tokens = filename.toLowerCase().split(/[.\s_\-/\\]+/);
+  let resolution;
+  let codec;
+  for (const token of tokens) {
+    if (!resolution && RESOLUTION_MAP[token]) resolution = RESOLUTION_MAP[token];
+    if (!codec && CODEC_MAP[token]) codec = CODEC_MAP[token];
+    if (resolution && codec) break;
+  }
+  return { resolution, codec };
+};
+var normalizeResolution = (s) => RESOLUTION_MAP[s.toLowerCase()] ?? s;
+var normalizeCodec = (s) => CODEC_MAP[s.toLowerCase()] ?? s;
+
+// src/refs/subtitleExtensions.json
+var subtitleExtensions_default = ["srt", "sub", "idx", "ass", "ssa", "vtt", "sup"];
+
+// src/refs/videoExtensions.json
+var videoExtensions_default = [
+  "3g2",
+  "3gp",
+  "aaf",
+  "asf",
+  "avchd",
+  "avi",
+  "drc",
+  "flv",
+  "m2v",
+  "m4p",
+  "m4v",
+  "mkv",
+  "mng",
+  "mov",
+  "mp2",
+  "mp4",
+  "mpe",
+  "mpeg",
+  "mpg",
+  "mpv",
+  "mxf",
+  "nsv",
+  "ogg",
+  "ogv",
+  "qt",
+  "rm",
+  "rmvb",
+  "roq",
+  "svi",
+  "vob",
+  "webm",
+  "wmv",
+  "yuv"
+];
+
+// src/actions/list.ts
+var DEST_TYPES2 = ["movie", "tv", "ps3"];
+var findVideoFile = (dir) => {
+  try {
+    return (0, import_fs8.readdirSync)(dir).find((f) => {
+      const ext = f.match(/([^.]+$)/)?.[0]?.toLowerCase();
+      return ext && videoExtensions_default.includes(ext);
+    }) ?? null;
+  } catch {
+    return null;
+  }
+};
+var hasSubtitle = (dir) => {
+  try {
+    return (0, import_fs8.readdirSync)(dir).some((f) => {
+      const ext = f.match(/([^.]+$)/)?.[0]?.toLowerCase();
+      return ext && subtitleExtensions_default.includes(ext);
+    });
+  } catch {
+    return false;
+  }
+};
+var parseLibraryFolder = (name) => {
+  const match = name.match(/^(.+?)\s*\((\d{4})\)/);
+  if (match) return { title: match[1].trim(), year: parseInt(match[2]) };
+  return { title: name };
+};
+var list = async ({ type, missingSubs, codec: codecFilter, resolution: resFilter, sort }) => {
+  const config = getConfig();
+  const types = (type ? [type] : DEST_TYPES2).filter((t) => config.dest[t]);
+  if (types.length === 0) throw new Error("no destinations configured \u2014 run: reelsort config set dest movie <dir>");
+  for (const t of types) {
+    const destRoot = config.dest[t];
+    if (!(0, import_fs8.existsSync)(destRoot)) {
+      console.log(`
+${t.toUpperCase()}  ${import_termkit9.Color.blue.encoder(destRoot)}  (not found)`);
+      continue;
+    }
+    const folders = (0, import_fs8.readdirSync)(destRoot).filter((f) => {
+      try {
+        return (0, import_fs8.lstatSync)((0, import_path9.resolve)(destRoot, f)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    const entries = folders.map((folder) => {
+      const folderPath = (0, import_path9.resolve)(destRoot, folder);
+      const parsed = parseLibraryFolder(folder);
+      const videoFile = findVideoFile(folderPath);
+      const mediaInfo = videoFile ? getMediaInfo((0, import_path9.resolve)(folderPath, videoFile)) : null;
+      const quality = mediaInfo ? { resolution: mediaInfo.resolution ?? void 0, codec: mediaInfo.codec ?? void 0 } : (() => {
+        const imp = getImportByDest(folderPath);
+        return imp ? parseQuality(imp.sourcePath) : {};
+      })();
+      return { ...parsed, ...quality, hasSub: hasSubtitle(folderPath), size: formatSize(dirSize(folderPath)) };
+    });
+    let filtered = entries;
+    if (missingSubs) filtered = filtered.filter((e) => !e.hasSub);
+    if (codecFilter) filtered = filtered.filter((e) => e.codec?.toLowerCase() === normalizeCodec(codecFilter).toLowerCase());
+    if (resFilter) filtered = filtered.filter((e) => e.resolution?.toLowerCase() === normalizeResolution(resFilter).toLowerCase());
+    filtered.sort((a, b) => {
+      if (sort === "title") return a.title.localeCompare(b.title);
+      const yearDiff = (b.year ?? 0) - (a.year ?? 0);
+      return yearDiff !== 0 ? yearDiff : a.title.localeCompare(b.title);
+    });
+    console.log(`
+${import_termkit9.Color.yellow.encoder(t.toUpperCase())}  ${import_termkit9.Color.blue.encoder(destRoot)}`);
+    new import_termkit9.Table(
+      filtered.map((e) => ({
+        title: e.title,
+        year: e.year,
+        resolution: e.resolution,
+        codec: e.codec,
+        size: e.size,
+        sub: e.hasSub
+      })),
+      {
+        separator: "  ",
+        columns: [
+          { key: "title", title: "Title" },
+          { key: "year", title: "Year", align: "right", value: (v) => v != null ? String(v) : "\u2014" },
+          { key: "resolution", title: "Res", value: (v) => v ?? "\u2014" },
+          { key: "codec", title: "Codec", value: (v) => v ?? "\u2014" },
+          { key: "size", title: "Size" },
+          { key: "sub", title: "Sub", value: (v) => v ? import_termkit9.Color.green.encoder("\u2713") : import_termkit9.Color.red.encoder("\u2717") }
+        ]
+      }
+    ).print();
+    console.log(`${filtered.length} of ${entries.length} item${entries.length !== 1 ? "s" : ""}`);
+  }
+  console.log();
+};
+var list_default = list;
+
+// src/actions/missing.ts
+var import_fs9 = require("fs");
+var import_path10 = require("path");
+var import_termkit10 = require("termkit");
+var TODAY = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+var parseSeasonNumber = (folderName) => {
+  const match = folderName.match(/(?:season|s)\s*0*(\d+)/i);
+  return match ? parseInt(match[1]) : null;
+};
+var parseEpisodeNumbers = (dir) => {
+  const episodes = /* @__PURE__ */ new Set();
+  for (const file of (0, import_fs9.readdirSync)(dir)) {
+    const ext = file.match(/([^.]+$)/)?.[0]?.toLowerCase();
+    if (!ext || !videoExtensions_default.includes(ext)) continue;
+    const m = file.match(/(?:S\d+E|(?:\d+)x)(\d+)/i);
+    if (m) episodes.add(parseInt(m[1]));
+  }
+  return episodes;
+};
+var subdirs2 = (dir) => (0, import_fs9.readdirSync)(dir).filter((f) => {
+  try {
+    return (0, import_fs9.lstatSync)((0, import_path10.resolve)(dir, f)).isDirectory();
+  } catch {
+    return false;
+  }
+});
+var missing = async ({ show: showFilter }) => {
+  const config = getConfig();
+  if (!config.tmdbApiKey) throw new Error("TMDb API key required \u2014 run: reelsort config set tmdb-key <key>");
+  const destRoot = config.dest.tv;
+  if (!destRoot) throw new Error("no TV destination configured \u2014 run: reelsort config set dest tv <dir>");
+  if (!(0, import_fs9.existsSync)(destRoot)) throw new Error(`TV destination not found: ${destRoot}`);
+  const filter = showFilter?.toLowerCase();
+  const allShows = getShows();
+  const endedPaths = new Set(allShows.filter((s) => s.ended).map((s) => s.path));
+  let totalMissing = 0;
+  let skippedEnded = 0;
+  for (const show of subdirs2(destRoot)) {
+    const showPath = (0, import_path10.resolve)(destRoot, show);
+    if (filter && !show.toLowerCase().includes(filter)) continue;
+    if (endedPaths.has(showPath)) {
+      skippedEnded++;
+      continue;
+    }
+    const tmdbId = getTmdbIdForShow(showPath);
+    if (!tmdbId) continue;
+    const showMissing = [];
+    for (const seasonFolder of subdirs2(showPath)) {
+      const seasonNum = parseSeasonNumber(seasonFolder);
+      if (seasonNum === null) continue;
+      const seasonPath = (0, import_path10.resolve)(showPath, seasonFolder);
+      const onDisk = parseEpisodeNumbers(seasonPath);
+      const episodes = await getSeasonEpisodes(tmdbId, seasonNum, config.tmdbApiKey);
+      for (const ep of episodes) {
+        if (ep.airDate && ep.airDate > TODAY) continue;
+        if (!onDisk.has(ep.episode)) {
+          const s = seasonNum.toString().padStart(2, "0");
+          const e = ep.episode.toString().padStart(2, "0");
+          showMissing.push(`  S${s}E${e} \u2014 ${ep.name}`);
+        }
+      }
+    }
+    if (showMissing.length > 0) {
+      totalMissing += showMissing.length;
+      console.log(`
+${import_termkit10.Color.yellow.encoder(show)}`);
+      for (const line of showMissing) console.log(line);
+    }
+  }
+  if (totalMissing === 0) {
+    console.log("\nNo missing episodes found");
+  } else {
+    console.log(`
+${totalMissing} missing episode${totalMissing !== 1 ? "s" : ""} total`);
+  }
+  if (skippedEnded > 0) {
+    console.log(`\x1B[2m${skippedEnded} ended show${skippedEnded !== 1 ? "s" : ""} skipped\x1B[0m`);
+  }
+  console.log();
+};
+var missing_default = missing;
+
+// src/actions/probe.ts
+var import_child_process = require("child_process");
+var import_fs10 = require("fs");
+var import_path11 = require("path");
+var import_termkit11 = require("termkit");
+var DEST_TYPES3 = ["movie", "tv", "ps3"];
+var CODEC_MAP2 = {
+  hevc: "x265",
+  h265: "x265",
+  h264: "x264",
+  avc: "x264",
+  av1: "AV1",
+  vp9: "VP9",
+  vp8: "VP8",
+  xvid: "XviD",
+  mpeg4: "XviD",
+  mpeg2video: "MPEG-2"
+};
+var deriveResolution = (width, height) => {
+  if (height >= 2160 || width >= 3840) return "2160p";
+  if (height >= 1080 || width >= 1920) return "1080p";
+  if (height >= 720 || width >= 1280) return "720p";
+  if (height >= 576 || width >= 768) return "576p";
+  return "480p";
+};
+var isFfprobeAvailable = () => {
+  const result = (0, import_child_process.spawnSync)("ffprobe", ["-version"], { encoding: "utf-8" });
+  return !result.error && result.status === 0;
+};
+var runFfprobe = (filePath) => {
+  const result = (0, import_child_process.spawnSync)("ffprobe", ["-v", "quiet", "-print_format", "json", "-show_streams", "-show_format", filePath], { encoding: "utf-8" });
+  if (result.error || result.status !== 0) return null;
+  try {
+    const data = JSON.parse(result.stdout);
+    const video = data.streams?.find((s) => s.codec_type === "video");
+    if (!video) return null;
+    const width = video.width ?? null;
+    const height = video.height ?? null;
+    return {
+      codec: CODEC_MAP2[video.codec_name?.toLowerCase()] ?? video.codec_name ?? null,
+      resolution: width && height ? deriveResolution(width, height) : null,
+      width: width ?? null,
+      height: height ?? null,
+      duration: data.format?.duration ? parseFloat(data.format.duration) : null
+    };
+  } catch {
+    return null;
+  }
+};
+var walkVideoFiles = (dir, depth = 0, maxDepth = 3) => {
+  if (!(0, import_fs10.existsSync)(dir) || depth > maxDepth) return [];
+  const results = [];
+  for (const entry of (0, import_fs10.readdirSync)(dir)) {
+    const entryPath = (0, import_path11.resolve)(dir, entry);
+    try {
+      if ((0, import_fs10.lstatSync)(entryPath).isDirectory()) {
+        results.push(...walkVideoFiles(entryPath, depth + 1, maxDepth));
+      } else {
+        const ext = entry.match(/([^.]+$)/)?.[0]?.toLowerCase();
+        if (ext && videoExtensions_default.includes(ext)) results.push(entryPath);
+      }
+    } catch {
+    }
+  }
+  return results;
+};
+var probe = async ({ type, force, verbose }) => {
+  spinner_default.start();
+  if (!isFfprobeAvailable()) {
+    spinner_default.fail("ffprobe not found \u2014 install ffmpeg to use this command");
+    spinner_default.stop();
+    return;
+  }
+  const config = getConfig();
+  const types = (type ? [type] : DEST_TYPES3).filter((t) => config.dest[t]);
+  if (types.length === 0) throw new Error("no destinations configured \u2014 run: reelsort config set dest movie <dir>");
+  let probed = 0, skipped = 0, failed = 0;
+  for (const t of types) {
+    const destRoot = config.dest[t];
+    if (!(0, import_fs10.existsSync)(destRoot)) continue;
+    spinner_default.text = `scanning ${import_termkit11.Color.blue.encoder(destRoot)}`;
+    const files = walkVideoFiles(destRoot);
+    for (const filePath of files) {
+      if (!force && getMediaInfo(filePath)) {
+        if (verbose) spinner_default.info(`already probed: ${filePath}`);
+        skipped++;
+        continue;
+      }
+      spinner_default.text = `probing ${import_termkit11.Color.blue.encoder(filePath)}`;
+      const result = runFfprobe(filePath);
+      if (!result) {
+        if (verbose) spinner_default.warn(`ffprobe failed: ${filePath}`);
+        failed++;
+        continue;
+      }
+      upsertMediaInfo(filePath, result.codec, result.resolution, result.width, result.height, result.duration);
+      if (verbose) spinner_default.succeed(`${result.resolution ?? "?"} ${result.codec ?? "?"}  ${filePath}`);
+      probed++;
+    }
+  }
+  spinner_default.succeed(`probed ${probed} files`);
+  if (skipped) spinner_default.info(`skipped ${skipped} already indexed`);
+  if (failed) spinner_default.warn(`failed ${failed} files`);
+  spinner_default.stop();
+};
+var probe_default = probe;
+
+// src/actions/rename.ts
+var import_fs11 = require("fs");
+var import_path12 = require("path");
+var import_rimraf = require("rimraf");
+var import_termkit12 = require("termkit");
+
+// src/helpers/findSubtitle.ts
+var LANGUAGE_ALIASES = {
+  eng: ["en", "english"],
+  fre: ["fr", "french"],
+  spa: ["es", "spanish"],
+  ger: ["de", "german"],
+  ita: ["it", "italian"],
+  por: ["pt", "portuguese"],
+  rus: ["ru", "russian"],
+  jpn: ["ja", "japanese"],
+  chi: ["zh", "chinese"]
+};
+var matchesLanguage = (filename, lang) => {
+  const base = filename.replace(/\.[^.]+$/, "").toLowerCase();
+  const codes = [lang.toLowerCase(), ...LANGUAGE_ALIASES[lang.toLowerCase()] ?? []];
+  return codes.some((code) => base.endsWith(`.${code}`) || base.endsWith(`_${code}`) || base.endsWith(`-${code}`) || base.includes(`.${code}.`));
+};
+var findSubtitle = (files, language) => {
+  const subs = files.filter((f) => {
+    const ext = f.match(/([^.]+$)/)?.[0]?.toLowerCase();
+    return ext && subtitleExtensions_default.includes(ext);
+  });
+  if (subs.length === 0) return null;
+  if (subs.length === 1) return subs[0];
+  return subs.find((f) => matchesLanguage(f, language)) ?? subs[0];
+};
+
+// src/helpers/titleCase.ts
+var import_roman_numeral = require("roman-numeral");
+var import_to_title_case = __toESM(require("to-title-case"));
+var titleCase_default = (s) => {
+  s = (0, import_to_title_case.default)(s);
+  const ws = s.toLowerCase().split(" ");
+  for (let i = 1; i <= 100; i++) {
+    const roman = (0, import_roman_numeral.convert)(i);
+    if (roman.length <= 1) continue;
+    if (ws.includes(roman.toLowerCase())) {
+      s = s.replace(new RegExp(roman, "i"), roman);
+    }
+  }
+  const ch = s.split("");
+  for (const [i, e] of ch.entries()) {
+    if (e !== "-" || !ch[i + 1]) continue;
+    if (ch[i + 1] === " " && ch[i + 2] && ch[i + 2] !== ch[i + 2].toUpperCase()) {
+      s = `${i ? s.substring(0, i) : ""}${`- ${ch[i + 2].toUpperCase()}`}${s.substring(i + 3, s.length)}`;
+    } else if (ch[i + 1] !== ch[i + 1].toUpperCase()) {
+      s = `${i ? s.substring(0, i) : ""}${`-${ch[i + 1].toUpperCase()}`}${s.substring(i + 2, s.length)}`;
+    }
+  }
+  return s;
+};
+
+// src/actions/rename.ts
+var rename = async ({ dir: inputDir, type, verbose }) => {
+  const dir = (0, import_path12.resolve)(inputDir);
+  const sessionId = (/* @__PURE__ */ new Date()).toISOString();
+  const config = getConfig();
+  const language = config.language ?? "eng";
+  const movieFormat = config.format?.movie ?? DEFAULT_MOVIE_FORMAT;
+  spinner_default.text = `renaming in ${import_termkit12.Color.blue.encoder(dir)}`;
+  spinner_default.start();
+  if (!(0, import_fs11.existsSync)(dir)) throw new Error(`dir ${dir} does not exist`);
+  const list2 = (0, import_fs11.readdirSync)(dir);
+  let renamed = 0, removed = 0, skipped = 0;
+  for (const [index, entry] of list2.entries()) {
+    spinner_default.text = `renaming in ${import_termkit12.Color.blue.encoder(dir)} ${index + 1}/${list2.length}`;
+    if (!(0, import_fs11.lstatSync)((0, import_path12.resolve)(dir, entry)).isDirectory()) {
+      if (verbose) spinner_default.info(`skipped ${entry}`);
+      skipped++;
+      continue;
+    }
+    const isPs3Candidate = /(?<=\[).+?(?=\])/.test(entry);
+    const usePs3 = type === "ps3" || !type && isPs3Candidate;
+    if (usePs3) {
+      const nameMatch = entry.match(/(?<=\[).+?(?=\])/);
+      const id = entry.split("-")[0];
+      if (!nameMatch || !id) {
+        if (verbose) spinner_default.info(`skipped ${entry}`);
+        skipped++;
+        continue;
+      }
+      const ps3Old = (0, import_path12.resolve)(dir, entry);
+      const ps3New = (0, import_path12.resolve)(dir, `${nameMatch[0]} [${id}]`);
+      (0, import_fs11.renameSync)(ps3Old, ps3New);
+      recordRename(sessionId, ps3Old, ps3New);
+      spinner_default.succeed(`${nameMatch[0]} [${id}]`);
+      renamed++;
+      continue;
+    }
+    const yearMatch = entry.match(/\([^\d]*(\d+)[^\d]*\)/);
+    if (!yearMatch) {
+      if (verbose) spinner_default.info(`skipped ${entry}`);
+      skipped++;
+      continue;
+    }
+    const year = yearMatch[0];
+    if (year.length !== 6) {
+      if (verbose) spinner_default.info(`skipped ${entry}`);
+      skipped++;
+      continue;
+    }
+    const title = titleCase_default(entry.substring(0, entry.indexOf(year)).trim());
+    const sublist = (0, import_fs11.readdirSync)((0, import_path12.resolve)(dir, entry));
+    const video = sublist.find((f) => {
+      const ext2 = f.match(/([^.]+$)/)?.[0];
+      return videoExtensions_default.includes(ext2) && title.split(" ").reduce((a, w) => f.toLowerCase().includes(w.toLowerCase()) ? a : false, true);
+    });
+    if (!video) {
+      if (verbose) spinner_default.info(`skipped ${entry}`);
+      skipped++;
+      continue;
+    }
+    const ext = video.match(/([^.]+$)/)?.[0];
+    if (!ext) {
+      if (verbose) spinner_default.info(`skipped ${entry}`);
+      skipped++;
+      continue;
+    }
+    const yearNum = parseInt(year.replace(/\D/g, ""));
+    const formatted = formatMovieName(movieFormat, title, yearNum);
+    if (entry === formatted && video === `${formatted}.${ext}`) {
+      if (verbose) spinner_default.info(`skipped ${entry}`);
+      skipped++;
+      continue;
+    }
+    const subtitle = findSubtitle(sublist, language);
+    const subtitleExt = subtitle?.match(/([^.]+$)/)?.[0];
+    const keep = new Set([video, subtitle].filter(Boolean));
+    const others = sublist.filter((f) => !keep.has(f));
+    for (const f of others) {
+      await (0, import_rimraf.rimraf)((0, import_path12.resolve)(dir, entry, f));
+      removed++;
+    }
+    const fileOld = (0, import_path12.resolve)(dir, entry, video);
+    const fileNew = (0, import_path12.resolve)(dir, entry, `${formatted}.${ext}`);
+    const folderOld = (0, import_path12.resolve)(dir, entry);
+    const folderNew = (0, import_path12.resolve)(dir, formatted);
+    (0, import_fs11.renameSync)(fileOld, fileNew);
+    if (subtitle && subtitleExt) {
+      (0, import_fs11.renameSync)((0, import_path12.resolve)(dir, entry, subtitle), (0, import_path12.resolve)(dir, entry, `${formatted}.${subtitleExt}`));
+    }
+    (0, import_fs11.renameSync)(folderOld, folderNew);
+    recordRename(sessionId, fileOld, fileNew);
+    recordRename(sessionId, folderOld, folderNew);
+    spinner_default.succeed(formatted);
+    renamed++;
+  }
+  spinner_default.succeed(`renamed ${renamed} files`);
+  if (removed) spinner_default.info(`removed ${removed} files`);
+  spinner_default.info(`skipped ${skipped} files`);
+  spinner_default.succeed(`done in ${import_termkit12.Color.cyan.encoder(dir)}`);
+  spinner_default.stop();
+};
+var rename_default = rename;
+
+// src/actions/reset.ts
+var import_fs12 = require("fs");
+var import_path13 = require("path");
+var import_termkit13 = require("termkit");
+var reset = async ({ dir: inputDir, double }) => {
+  let dir = inputDir;
+  spinner_default.text = `resetting episodes in ${import_termkit13.Color.blue.encoder(dir)}`;
+  spinner_default.start();
+  dir = (0, import_path13.resolve)(dir);
+  if (!(0, import_fs12.existsSync)(dir)) throw new Error(`dir ${dir} does not exist`);
+  const list2 = (0, import_fs12.readdirSync)(dir).sort();
+  const folder = dir.replace(/\./g, " ").split(import_path13.sep).pop();
+  let season;
+  let sub = folder.includes("season") ? folder.substring(folder.indexOf("season") + "season".length, folder.length).trim() : /s\d/i.test(folder) ? folder.substring(folder.search(/s\d/i) + 1, folder.length).trim() : null;
+  if (sub)
+    while (sub.search(/[0-9]/) === 0) {
+      season = `${season || ""}${sub.substring(0, 1)}`;
+      sub = sub.substring(1, sub.length);
+    }
+  const seasonNum = parseInt(season);
+  if (!seasonNum) throw new Error(`unable to identify season number`);
+  const parentFolder = (0, import_path13.basename)((0, import_path13.dirname)(dir));
+  const showTitle = parentFolder.match(/^(.+?)\s*(?:\(\d{4}\))?$/)?.[1]?.trim() || void 0;
+  spinner_default.info(`identified as season ${seasonNum}${showTitle ? ` of ${showTitle}` : ""}`);
+  const sublist = list2.filter((f) => {
+    const ext = f.match(/([^.]+$)/)?.[0];
+    return videoExtensions_default.includes(ext) && f.split(" ").reduce((a, w) => f.toLowerCase().includes(w.toLowerCase()) ? a : false, true);
+  });
+  const other = list2.filter((f) => {
+    const ext = f.match(/([^.]+$)/)?.[0];
+    return !videoExtensions_default.includes(ext) && f.split(" ").reduce((a, w) => f.toLowerCase().includes(w.toLowerCase()) ? a : false, true);
+  });
+  const episodeFormat = getConfig().format?.episode;
+  let renamed = 0, skipped = other.length;
+  for (const [index, i] of sublist.entries()) {
+    spinner_default.text = `resetting episodes in ${import_termkit13.Color.blue.encoder(dir)} ${index}/${list2.length}`;
+    const ext = i.match(/([^.]+$)/)?.[0];
+    const episode = double ? index * 2 + 1 : index + 1;
+    const name = `${formatEpisode(seasonNum, episode, episodeFormat, double, showTitle)}.${ext}`;
+    if (i === name) {
+      skipped++;
+      continue;
+    }
+    (0, import_fs12.renameSync)((0, import_path13.resolve)(dir, i), (0, import_path13.resolve)(dir, name));
+    renamed++;
+  }
+  spinner_default.succeed(`renamed ${renamed} files`);
+  spinner_default.info(`skipped ${skipped} files`);
+  spinner_default.succeed(`done in ${import_termkit13.Color.cyan.encoder(dir)}`);
+  spinner_default.stop();
+};
+var reset_default = reset;
+
+// src/actions/scan.ts
+var import_fs13 = require("fs");
+var import_path14 = require("path");
+var import_termkit14 = require("termkit");
+
+// src/helpers/detectEdition.ts
+var EDITIONS = [
+  { pattern: /director.?s?.?cut/i, name: "Director's Cut" },
+  { pattern: /final\.?cut/i, name: "Final Cut" },
+  { pattern: /extended\.?(cut|edition|version)?/i, name: "Extended" },
+  { pattern: /theatrical\.?(cut|version)?/i, name: "Theatrical" },
+  { pattern: /unrated\.?(cut|version)?/i, name: "Unrated" },
+  { pattern: /anniversary\.?edition/i, name: "Anniversary Edition" },
+  { pattern: /collector.?s?.?(edition|cut)/i, name: "Collector's Edition" },
+  { pattern: /special\.?edition/i, name: "Special Edition" }
+];
+var detectEdition = (filename) => {
+  for (const { pattern, name } of EDITIONS) {
+    if (pattern.test(filename)) return name;
+  }
+  return null;
+};
+
+// src/helpers/parseDownloadName.ts
+var QUALITY_TOKENS = /* @__PURE__ */ new Set(["480p", "576p", "720p", "1080p", "2160p", "4k", "8k", "bluray", "bdrip", "bdremux", "brrip", "webrip", "web-dl", "webdl", "web", "hdtv", "dvdrip", "dvdscr", "cam", "ts", "scr", "x264", "x265", "hevc", "avc", "h264", "h265", "xvid", "divx", "dts", "ac3", "aac", "mp3", "truehd", "atmos", "dd5", "hdr", "hdr10", "hlg", "dv", "dolby", "remux", "proper", "repack", "extended", "theatrical", "unrated", "multi", "dubbed", "subbed", "internal"]);
+var TV_PATTERN = /^(.*?)[.\s_-]*(?:S(\d{2,3})E(\d{2,3})|(\d{1,2})x(\d{2,3})|Season[\s.](\d+))/i;
+var parseDownloadName = (name) => {
+  const base = name.replace(/\.[a-z0-9]{2,4}$/i, "");
+  const tvMatch = TV_PATTERN.exec(base);
+  if (tvMatch) {
+    const raw = tvMatch[1].replace(/[._]/g, " ").replace(/\[.*?\]/g, "").trim();
+    const title = titleCase_default(raw);
+    if (!title) return null;
+    const season = parseInt(tvMatch[2] ?? tvMatch[4] ?? tvMatch[6]);
+    const episode = parseInt(tvMatch[3] ?? tvMatch[5]);
+    return {
+      title,
+      type: "tv",
+      season: isNaN(season) ? void 0 : season,
+      episode: isNaN(episode) ? void 0 : episode
+    };
+  }
+  const normalized = base.replace(/[._]/g, " ").replace(/\[.*?\]/g, "").trim();
+  const tokens = normalized.split(/\s+/);
+  let stopIndex = tokens.length;
+  let year;
+  for (let i = 0; i < tokens.length; i++) {
+    const n = parseInt(tokens[i]);
+    if (!isNaN(n) && tokens[i].length === 4 && n >= 1900 && n <= 2099) {
+      year = n;
+      stopIndex = i;
+      break;
+    }
+    if (QUALITY_TOKENS.has(tokens[i].toLowerCase())) {
+      stopIndex = i;
+      break;
+    }
+  }
+  const titleTokens = tokens.slice(0, stopIndex);
+  if (titleTokens.length === 0) return null;
+  return { title: titleCase_default(titleTokens.join(" ")), year, type: "movie" };
+};
+
+// src/actions/scan.ts
+var sameDev = (a, b) => {
+  try {
+    let bExisting = b;
+    while (!(0, import_fs13.existsSync)(bExisting)) bExisting = (0, import_path14.dirname)(bExisting);
+    return (0, import_fs13.statSync)(a).dev === (0, import_fs13.statSync)(bExisting).dev;
+  } catch {
+    return false;
+  }
+};
+var moveFolder = (src, dest) => {
+  if (sameDev(src, dest)) {
+    (0, import_fs13.renameSync)(src, dest);
+  } else {
+    (0, import_fs13.cpSync)(src, dest, { recursive: true });
+    (0, import_fs13.rmSync)(src, { recursive: true, force: true });
+  }
+};
+var findVideo = (dir) => (0, import_fs13.readdirSync)(dir).find((f) => {
+  const ext = f.match(/([^.]+$)/)?.[0];
+  return ext && videoExtensions_default.includes(ext);
+}) ?? null;
+var findSeasonFolder = (showPath, season) => {
+  if (!(0, import_fs13.existsSync)(showPath)) return null;
+  const folders = (0, import_fs13.readdirSync)(showPath).filter((f) => {
+    try {
+      return (0, import_fs13.lstatSync)((0, import_path14.resolve)(showPath, f)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  return folders.find((f) => {
+    const match = f.match(/(?:season|s)\s*0*(\d+)/i);
+    return match && parseInt(match[1]) === season;
+  }) ?? null;
+};
+var scan = async ({ type, hardlink: useHardlink, dryRun, verbose, auto }) => {
+  const config = getConfig();
+  const sessionId = (/* @__PURE__ */ new Date()).toISOString();
+  const language = config.language ?? "eng";
+  const movieFormat = config.format?.movie ?? DEFAULT_MOVIE_FORMAT;
+  const seasonFormat = config.format?.season ?? DEFAULT_SEASON_FORMAT;
+  spinner_default.start();
+  if (config.sources.length === 0) throw new Error("no sources configured \u2014 run: reelsort config add source <dir>");
+  let imported = 0, skipped = 0;
+  for (const source of config.sources) {
+    if (!(0, import_fs13.existsSync)(source)) {
+      spinner_default.warn(`source not found: ${import_termkit14.Color.blue.encoder(source)}`);
+      continue;
+    }
+    spinner_default.text = `scanning ${import_termkit14.Color.blue.encoder(source)}`;
+    for (const entry of (0, import_fs13.readdirSync)(source)) {
+      const entryPath = (0, import_path14.resolve)(source, entry);
+      const isDir = (0, import_fs13.lstatSync)(entryPath).isDirectory();
+      const ext = entry.match(/([^.]+$)/)?.[0];
+      const isVideo = !isDir && ext && videoExtensions_default.includes(ext);
+      if (!isDir && !isVideo) {
+        if (verbose) spinner_default.info(`skipped ${entry}`);
+        skipped++;
+        continue;
+      }
+      let detectedType;
+      if (type) {
+        detectedType = type;
+      } else if (isDir && /(?<=\[).+?(?=\])/.test(entry)) {
+        detectedType = "ps3";
+      } else if (/S\d{2,3}E\d{2,3}/i.test(entry) || /\d+x\d{2,3}/i.test(entry)) {
+        detectedType = "tv";
+      } else {
+        detectedType = "movie";
+      }
+      const destRoot = config.dest[detectedType];
+      if (!destRoot) {
+        if (verbose) spinner_default.info(`no ${detectedType} destination configured, skipped: ${entry}`);
+        skipped++;
+        continue;
+      }
+      if (detectedType === "ps3") {
+        const nameMatch = entry.match(/(?<=\[).+?(?=\])/);
+        const id = entry.split("-")[0];
+        if (!nameMatch || !id) {
+          skipped++;
+          continue;
+        }
+        const destName = `${nameMatch[0]} [${id}]`;
+        const destPath = (0, import_path14.resolve)(destRoot, destName);
+        if ((0, import_fs13.existsSync)(destPath)) {
+          spinner_default.warn(`already exists: ${destName}`);
+          skipped++;
+          continue;
+        }
+        if (!dryRun) {
+          moveFolder(entryPath, destPath);
+          recordImport(sessionId, entryPath, destPath, "move");
+        }
+        spinner_default.succeed(`${dryRun ? "[dry] " : ""}${destName}`);
+        imported++;
+        continue;
+      }
+      const parsed = parseDownloadName(entry);
+      if (!parsed) {
+        if (verbose) spinner_default.info(`could not parse: ${entry}`);
+        skipped++;
+        continue;
+      }
+      let tmdbId;
+      let resolvedTitle = parsed.title;
+      let resolvedYear = parsed.year;
+      if (config.tmdbApiKey) {
+        if (detectedType === "tv") {
+          const results = await searchTv(parsed.title, config.tmdbApiKey);
+          if (results.length === 1) {
+            tmdbId = results[0].id;
+            resolvedTitle = results[0].title;
+            resolvedYear = results[0].year ?? parsed.year;
+          } else if (results.length > 1) {
+            spinner_default.stop();
+            const select = new import_termkit14.Select();
+            const items = results.map((r) => ({
+              label: r.year ? `${r.title} (${r.year})` : r.title,
+              description: [r.overview?.slice(0, 60), hyperlink(r.url, "themoviedb.org")].filter(Boolean).join(" \xB7 "),
+              ...r
+            }));
+            const picked = await select.ask(`Multiple shows found for "${parsed.title}":`, items);
+            spinner_default.start();
+            if (picked) {
+              tmdbId = picked.id;
+              resolvedTitle = picked.title;
+              resolvedYear = picked.year ?? parsed.year;
+            }
+          }
+        } else {
+          const tmdb = await searchMovie(parsed.title, parsed.year, config.tmdbApiKey);
+          if (tmdb) {
+            tmdbId = tmdb.id;
+            resolvedTitle = tmdb.title;
+            resolvedYear = tmdb.year ?? parsed.year;
+          }
+        }
+      }
+      if (detectedType === "tv") {
+        if (parsed.season === void 0) {
+          if (verbose) spinner_default.info(`could not detect season from: ${entry}`);
+          skipped++;
+          continue;
+        }
+        const registeredShow = getShowByTitle(resolvedTitle);
+        let showPath;
+        let showFolderName;
+        if (registeredShow) {
+          showPath = registeredShow.path;
+          showFolderName = showPath.split("/").pop() ?? registeredShow.path;
+        } else if (auto) {
+          showFolderName = formatMovieName(movieFormat, resolvedTitle, resolvedYear);
+          showPath = (0, import_path14.resolve)(destRoot, showFolderName);
+          if (!dryRun) upsertShow(showPath, tmdbId ?? null, resolvedTitle);
+        } else {
+          if (verbose) spinner_default.info(`not registered, skipped: ${resolvedTitle} \u2014 run: reelsort add "${resolvedTitle}"`);
+          skipped++;
+          continue;
+        }
+        const seasonFolderName = findSeasonFolder(showPath, parsed.season) ?? formatSeasonFolder(seasonFormat, parsed.season);
+        const seasonPath = (0, import_path14.resolve)(showPath, seasonFolderName);
+        const videoFile2 = isDir ? findVideo(entryPath) : entry;
+        if (!videoFile2) {
+          if (verbose) spinner_default.info(`no video found in: ${entry}`);
+          skipped++;
+          continue;
+        }
+        const videoExt2 = videoFile2.match(/([^.]+$)/)?.[0];
+        const tmdbEpisodeName = tmdbId && config.tmdbApiKey ? await getEpisodeName(tmdbId, parsed.season, parsed.episode ?? 1, config.tmdbApiKey) : null;
+        const episodeName = formatEpisode(parsed.season, parsed.episode ?? 1, config.format?.episode, false, resolvedTitle, tmdbEpisodeName ?? void 0);
+        const destVideoName2 = `${episodeName}.${videoExt2}`;
+        const destVideoPath = (0, import_path14.resolve)(seasonPath, destVideoName2);
+        const videoSourcePath2 = isDir ? (0, import_path14.resolve)(entryPath, videoFile2) : entryPath;
+        if ((0, import_fs13.existsSync)(destVideoPath)) {
+          spinner_default.warn(`already exists: ${episodeName}`);
+          skipped++;
+          continue;
+        }
+        const dirFiles2 = isDir ? (0, import_fs13.readdirSync)(entryPath) : [];
+        const subtitle2 = isDir ? findSubtitle(dirFiles2, language) : null;
+        const subtitleExt2 = subtitle2?.match(/([^.]+$)/)?.[0];
+        const subtitleSourcePath2 = subtitle2 ? (0, import_path14.resolve)(entryPath, subtitle2) : null;
+        const destSubtitleName2 = subtitle2 && subtitleExt2 ? `${episodeName}.${subtitleExt2}` : null;
+        if (!dryRun) {
+          (0, import_fs13.mkdirSync)(seasonPath, { recursive: true });
+          let mode = "move";
+          if (useHardlink) {
+            try {
+              if (!sameDev(videoSourcePath2, seasonPath)) throw new Error("cross-filesystem");
+              (0, import_fs13.linkSync)(videoSourcePath2, destVideoPath);
+              mode = "hardlink";
+            } catch {
+              spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${episodeName}`);
+              (0, import_fs13.cpSync)(videoSourcePath2, destVideoPath);
+              mode = "copy";
+            }
+            if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs13.cpSync)(subtitleSourcePath2, (0, import_path14.resolve)(seasonPath, destSubtitleName2));
+          } else {
+            if (sameDev(videoSourcePath2, seasonPath)) {
+              (0, import_fs13.renameSync)(videoSourcePath2, destVideoPath);
+            } else {
+              (0, import_fs13.cpSync)(videoSourcePath2, destVideoPath);
+              (0, import_fs13.rmSync)(videoSourcePath2);
+            }
+            if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs13.renameSync)(subtitleSourcePath2, (0, import_path14.resolve)(seasonPath, destSubtitleName2));
+            if (isDir) (0, import_fs13.rmSync)(entryPath, { recursive: true, force: true });
+          }
+          recordImport(sessionId, entryPath, seasonPath, mode, tmdbId);
+        }
+        spinner_default.succeed(`${dryRun ? "[dry] " : ""}${showFolderName} / ${seasonFolderName} / ${episodeName}`);
+        imported++;
+        continue;
+      }
+      const edition = detectEdition(entry);
+      const folderName = formatMovieName(movieFormat, resolvedTitle, resolvedYear, edition);
+      const destFolder = (0, import_path14.resolve)(destRoot, folderName);
+      if ((0, import_fs13.existsSync)(destFolder)) {
+        spinner_default.warn(`already exists: ${folderName}`);
+        skipped++;
+        continue;
+      }
+      const videoFile = isDir ? findVideo(entryPath) : entry;
+      if (!videoFile) {
+        if (verbose) spinner_default.info(`no video found in: ${entry}`);
+        skipped++;
+        continue;
+      }
+      const videoExt = videoFile.match(/([^.]+$)/)?.[0];
+      const destVideoName = `${folderName}.${videoExt}`;
+      const videoSourcePath = isDir ? (0, import_path14.resolve)(entryPath, videoFile) : entryPath;
+      const dirFiles = isDir ? (0, import_fs13.readdirSync)(entryPath) : [];
+      const subtitle = isDir ? findSubtitle(dirFiles, language) : null;
+      const subtitleExt = subtitle?.match(/([^.]+$)/)?.[0];
+      const subtitleSourcePath = subtitle ? (0, import_path14.resolve)(entryPath, subtitle) : null;
+      const destSubtitleName = subtitle && subtitleExt ? `${folderName}.${subtitleExt}` : null;
+      if (!dryRun) {
+        if (useHardlink) {
+          (0, import_fs13.mkdirSync)(destFolder, { recursive: true });
+          const destVideoPath = (0, import_path14.resolve)(destFolder, destVideoName);
+          let mode;
+          try {
+            if (!sameDev(videoSourcePath, destRoot)) throw new Error("cross-filesystem");
+            (0, import_fs13.linkSync)(videoSourcePath, destVideoPath);
+            mode = "hardlink";
+          } catch {
+            spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${folderName}`);
+            (0, import_fs13.cpSync)(videoSourcePath, destVideoPath);
+            mode = "copy";
+          }
+          if (subtitleSourcePath && destSubtitleName) (0, import_fs13.cpSync)(subtitleSourcePath, (0, import_path14.resolve)(destFolder, destSubtitleName));
+          recordImport(sessionId, entryPath, destFolder, mode, tmdbId);
+        } else {
+          if (isDir) {
+            const keep = new Set([videoFile, subtitle].filter(Boolean));
+            for (const f of dirFiles.filter((f2) => !keep.has(f2))) (0, import_fs13.rmSync)((0, import_path14.resolve)(entryPath, f), { recursive: true, force: true });
+            (0, import_fs13.renameSync)(videoSourcePath, (0, import_path14.resolve)(entryPath, destVideoName));
+            if (subtitleSourcePath && destSubtitleName) (0, import_fs13.renameSync)(subtitleSourcePath, (0, import_path14.resolve)(entryPath, destSubtitleName));
+            moveFolder(entryPath, destFolder);
+          } else {
+            (0, import_fs13.mkdirSync)(destFolder, { recursive: true });
+            const destVideoPath = (0, import_path14.resolve)(destFolder, destVideoName);
+            if (sameDev(videoSourcePath, destRoot)) {
+              (0, import_fs13.renameSync)(videoSourcePath, destVideoPath);
+            } else {
+              (0, import_fs13.cpSync)(videoSourcePath, destVideoPath);
+              (0, import_fs13.rmSync)(videoSourcePath);
+            }
+          }
+          recordImport(sessionId, entryPath, destFolder, "move", tmdbId);
+        }
+      }
+      spinner_default.succeed(`${dryRun ? "[dry] " : ""}${folderName}`);
+      imported++;
+    }
+  }
+  spinner_default.succeed(`imported ${imported} items`);
+  if (skipped) spinner_default.info(`skipped ${skipped} items`);
+  spinner_default.stop();
+};
+var scan_default = scan;
+
+// src/actions/shows.ts
+var import_fs14 = require("fs");
+var import_termkit15 = require("termkit");
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var shows = async () => {
+  const config = getConfig();
+  const destRoot = config.dest.tv;
+  const allShows = getShows();
+  if (allShows.length === 0) {
+    console.log("\nNo shows registered \u2014 run: reelsort add <name> or reelsort link");
+    console.log();
+    return;
+  }
+  console.log(`
+${import_termkit15.Color.yellow.encoder("SHOWS")}${destRoot ? `  ${import_termkit15.Color.blue.encoder(destRoot)}` : ""}  (${allShows.length} registered)`);
+  new import_termkit15.Table(
+    allShows.map((show) => ({
+      name: show.path.split("/").pop() ?? show.path,
+      size: (0, import_fs14.existsSync)(show.path) ? formatSize(dirSize(show.path)) : "\u2014",
+      tmdbId: show.tmdbId,
+      ended: show.ended
+    })),
+    {
+      separator: "  ",
+      columns: [
+        { key: "name", title: "Title" },
+        { key: "size", title: "Size" },
+        {
+          key: "tmdbId",
+          title: "Linked",
+          value: (v) => {
+            if (v) {
+              const url = `https://www.themoviedb.org/tv/${v}`;
+              const text = process.stdout.isTTY ? hyperlink(url, "\u2713 tmdb") : "\u2713 tmdb";
+              return import_termkit15.Color.green.encoder(text);
+            }
+            return import_termkit15.Color.red.encoder("\u2717");
+          }
+        },
+        { key: "ended", title: "Status", value: (v) => v ? dim("ended") : "active" }
+      ]
+    }
+  ).print();
+  const ended2 = allShows.filter((s) => s.ended).length;
+  const linked = allShows.filter((s) => s.tmdbId).length;
+  console.log(`${allShows.length} shows  \xB7  ${linked} linked  \xB7  ${ended2} ended`);
+  console.log();
+};
+var shows_default = shows;
+
+// src/actions/stats.ts
+var import_fs15 = require("fs");
+var import_path15 = require("path");
+var import_termkit16 = require("termkit");
+var countVideos = (dir) => {
+  let count = 0;
+  try {
+    for (const entry of (0, import_fs15.readdirSync)(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        count += countVideos((0, import_path15.resolve)(dir, entry.name));
+      } else {
+        const ext = entry.name.match(/([^.]+$)/)?.[0]?.toLowerCase();
+        if (ext && videoExtensions_default.includes(ext)) count++;
+      }
+    }
+  } catch {
+  }
+  return count;
+};
+var countDirs = (dir) => {
+  try {
+    return (0, import_fs15.readdirSync)(dir).filter((f) => {
+      try {
+        return (0, import_fs15.lstatSync)((0, import_path15.resolve)(dir, f)).isDirectory();
+      } catch {
+        return false;
+      }
+    }).length;
+  } catch {
+    return 0;
+  }
+};
+var stats = async () => {
+  const config = getConfig();
+  const shows2 = getShows();
+  const rows = [];
+  const movieDest = config.dest.movie;
+  if (movieDest && (0, import_fs15.existsSync)(movieDest)) {
+    rows.push({ category: "Movies", count: countDirs(movieDest), size: formatSize(dirSize(movieDest)) });
+  }
+  const tvDest = config.dest.tv;
+  if (tvDest && (0, import_fs15.existsSync)(tvDest)) {
+    rows.push({ category: "Shows", count: shows2.length, size: formatSize(dirSize(tvDest)) });
+    rows.push({ category: "Episodes", count: countVideos(tvDest) });
+  }
+  const ps3Dest = config.dest.ps3;
+  if (ps3Dest && (0, import_fs15.existsSync)(ps3Dest)) {
+    rows.push({ category: "PS3", count: countDirs(ps3Dest), size: formatSize(dirSize(ps3Dest)) });
+  }
+  if (rows.length === 0) return;
+  console.log();
+  new import_termkit16.Table(rows, {
+    title: "LIBRARY STATISTICS",
+    separator: "  ",
+    columns: [
+      { key: "category", title: "Category" },
+      { key: "count", title: "Count", align: "right", value: (v) => v != null ? String(v) : "" },
+      { key: "size", title: "Size", value: (v) => v ?? "" }
+    ]
+  }).print();
+  console.log();
+};
+var stats_default = stats;
+
+// src/actions/undo.ts
+var import_fs16 = require("fs");
+var import_termkit17 = require("termkit");
+var undo = async () => {
+  spinner_default.start();
+  const records = getLastSession();
+  if (records.length === 0) {
+    spinner_default.info("nothing to undo");
+    spinner_default.stop();
+    return;
+  }
+  let undone = 0;
+  for (const record of records) {
+    (0, import_fs16.renameSync)(record.newPath, record.oldPath);
+    spinner_default.succeed(`${import_termkit17.Color.cyan.encoder(record.newPath)} \u2192 ${import_termkit17.Color.blue.encoder(record.oldPath)}`);
+    undone++;
+  }
+  deleteSession(records[0].sessionId);
+  spinner_default.succeed(`undid ${undone} renames`);
+  spinner_default.stop();
+};
+var undo_default = undo;
+
+// src/actions/watch.ts
+var import_chokidar = __toESM(require("chokidar"));
+var import_fs17 = require("fs");
+var import_path16 = require("path");
+var import_termkit18 = require("termkit");
+var sameDev2 = (a, b) => {
+  try {
+    let bExisting = b;
+    while (!(0, import_fs17.existsSync)(bExisting)) bExisting = (0, import_path16.dirname)(bExisting);
+    return (0, import_fs17.statSync)(a).dev === (0, import_fs17.statSync)(bExisting).dev;
+  } catch {
+    return false;
+  }
+};
+var moveItem = (src, dest) => {
+  if (sameDev2(src, dest)) {
+    (0, import_fs17.renameSync)(src, dest);
+  } else {
+    (0, import_fs17.cpSync)(src, dest, { recursive: true });
+    (0, import_fs17.rmSync)(src, { recursive: true, force: true });
+  }
+};
+var findVideo2 = (dir) => (0, import_fs17.readdirSync)(dir).find((f) => {
+  const ext = f.match(/([^.]+$)/)?.[0];
+  return ext && videoExtensions_default.includes(ext);
+}) ?? null;
+var findSeasonFolder2 = (showPath, season) => {
+  if (!(0, import_fs17.existsSync)(showPath)) return null;
+  const folders = (0, import_fs17.readdirSync)(showPath).filter((f) => {
+    try {
+      return (0, import_fs17.lstatSync)((0, import_path16.resolve)(showPath, f)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  return folders.find((f) => {
+    const match = f.match(/(?:season|s)\s*0*(\d+)/i);
+    return match && parseInt(match[1]) === season;
+  }) ?? null;
+};
+var processItem = async (entryPath, useHardlink, verbose, language, auto) => {
+  const config = getConfig();
+  const sessionId = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = (0, import_path16.basename)(entryPath);
+  const movieFormat = config.format?.movie ?? DEFAULT_MOVIE_FORMAT;
+  const seasonFormat = config.format?.season ?? DEFAULT_SEASON_FORMAT;
+  const isDir = (0, import_fs17.lstatSync)(entryPath).isDirectory();
+  const ext = entry.match(/([^.]+$)/)?.[0];
+  const isVideo = !isDir && ext && videoExtensions_default.includes(ext);
+  if (!isDir && !isVideo) return;
+  let detectedType;
+  if (isDir && /(?<=\[).+?(?=\])/.test(entry)) {
+    detectedType = "ps3";
+  } else if (/S\d{2,3}E\d{2,3}/i.test(entry) || /\d+x\d{2,3}/i.test(entry)) {
+    detectedType = "tv";
+  } else {
+    detectedType = "movie";
+  }
+  const destRoot = config.dest[detectedType];
+  if (!destRoot) {
+    if (verbose) spinner_default.info(`no ${detectedType} destination configured, skipped: ${entry}`);
+    return;
+  }
+  if (detectedType === "ps3") {
+    const nameMatch = entry.match(/(?<=\[).+?(?=\])/);
+    const id = entry.split("-")[0];
+    if (!nameMatch || !id) return;
+    const destName = `${nameMatch[0]} [${id}]`;
+    const destPath = (0, import_path16.resolve)(destRoot, destName);
+    if ((0, import_fs17.existsSync)(destPath)) {
+      spinner_default.warn(`already exists: ${destName}`);
+      return;
+    }
+    moveItem(entryPath, destPath);
+    recordImport(sessionId, entryPath, destPath, "move");
+    spinner_default.succeed(`imported ${import_termkit18.Color.cyan.encoder(destName)}`);
+    return;
+  }
+  const parsed = parseDownloadName(entry);
+  if (!parsed) {
+    if (verbose) spinner_default.info(`could not parse: ${entry}`);
+    return;
+  }
+  if (detectedType === "tv") {
+    if (parsed.season === void 0) {
+      if (verbose) spinner_default.info(`could not detect season from: ${entry}`);
+      return;
+    }
+    const registeredShow = getShowByTitle(parsed.title);
+    let showPath;
+    let showFolderName;
+    if (registeredShow) {
+      showPath = registeredShow.path;
+      showFolderName = showPath.split("/").pop() ?? registeredShow.path;
+    } else if (auto) {
+      showFolderName = formatMovieName(movieFormat, parsed.title, parsed.year);
+      showPath = (0, import_path16.resolve)(destRoot, showFolderName);
+      upsertShow(showPath, null, parsed.title);
+    } else {
+      if (verbose) spinner_default.info(`not registered, skipped: ${parsed.title} \u2014 run: reelsort add "${parsed.title}"`);
+      return;
+    }
+    const seasonFolderName = findSeasonFolder2(showPath, parsed.season) ?? formatSeasonFolder(seasonFormat, parsed.season);
+    const seasonPath = (0, import_path16.resolve)(showPath, seasonFolderName);
+    const videoFile2 = isDir ? findVideo2(entryPath) : entry;
+    if (!videoFile2) {
+      if (verbose) spinner_default.info(`no video found in: ${entry}`);
+      return;
+    }
+    const videoExt2 = videoFile2.match(/([^.]+$)/)?.[0];
+    const tmdbEpisodeName = registeredShow?.tmdbId && config.tmdbApiKey ? await getEpisodeName(registeredShow.tmdbId, parsed.season, parsed.episode ?? 1, config.tmdbApiKey) : null;
+    const episodeName = formatEpisode(parsed.season, parsed.episode ?? 1, config.format?.episode, false, parsed.title, tmdbEpisodeName ?? void 0);
+    const destVideoName2 = `${episodeName}.${videoExt2}`;
+    const destVideoPath = (0, import_path16.resolve)(seasonPath, destVideoName2);
+    const videoSourcePath2 = isDir ? (0, import_path16.resolve)(entryPath, videoFile2) : entryPath;
+    if ((0, import_fs17.existsSync)(destVideoPath)) {
+      spinner_default.warn(`already exists: ${episodeName}`);
+      return;
+    }
+    const dirFiles2 = isDir ? (0, import_fs17.readdirSync)(entryPath) : [];
+    const subtitle2 = isDir ? findSubtitle(dirFiles2, language) : null;
+    const subtitleExt2 = subtitle2?.match(/([^.]+$)/)?.[0];
+    const subtitleSourcePath2 = subtitle2 ? (0, import_path16.resolve)(entryPath, subtitle2) : null;
+    const destSubtitleName2 = subtitle2 && subtitleExt2 ? `${episodeName}.${subtitleExt2}` : null;
+    (0, import_fs17.mkdirSync)(seasonPath, { recursive: true });
+    let mode = "move";
+    if (useHardlink) {
+      try {
+        if (!sameDev2(videoSourcePath2, seasonPath)) throw new Error("cross-filesystem");
+        (0, import_fs17.linkSync)(videoSourcePath2, destVideoPath);
+        mode = "hardlink";
+      } catch {
+        spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${episodeName}`);
+        (0, import_fs17.cpSync)(videoSourcePath2, destVideoPath);
+        mode = "copy";
+      }
+      if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs17.cpSync)(subtitleSourcePath2, (0, import_path16.resolve)(seasonPath, destSubtitleName2));
+    } else {
+      if (sameDev2(videoSourcePath2, seasonPath)) {
+        (0, import_fs17.renameSync)(videoSourcePath2, destVideoPath);
+      } else {
+        (0, import_fs17.cpSync)(videoSourcePath2, destVideoPath);
+        (0, import_fs17.rmSync)(videoSourcePath2);
+      }
+      if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs17.renameSync)(subtitleSourcePath2, (0, import_path16.resolve)(seasonPath, destSubtitleName2));
+      if (isDir) (0, import_fs17.rmSync)(entryPath, { recursive: true, force: true });
+    }
+    recordImport(sessionId, entryPath, seasonPath, mode);
+    spinner_default.succeed(`imported ${import_termkit18.Color.cyan.encoder(`${showFolderName} / ${seasonFolderName} / ${episodeName}`)}`);
+    return;
+  }
+  const edition = detectEdition(entry);
+  const folderName = formatMovieName(movieFormat, parsed.title, parsed.year, edition);
+  const destFolder = (0, import_path16.resolve)(destRoot, folderName);
+  if ((0, import_fs17.existsSync)(destFolder)) {
+    spinner_default.warn(`already exists: ${folderName}`);
+    return;
+  }
+  const videoFile = isDir ? findVideo2(entryPath) : entry;
+  if (!videoFile) {
+    if (verbose) spinner_default.info(`no video found in: ${entry}`);
+    return;
+  }
+  const videoExt = videoFile.match(/([^.]+$)/)?.[0];
+  const destVideoName = `${folderName}.${videoExt}`;
+  const videoSourcePath = isDir ? (0, import_path16.resolve)(entryPath, videoFile) : entryPath;
+  const dirFiles = isDir ? (0, import_fs17.readdirSync)(entryPath) : [];
+  const subtitle = isDir ? findSubtitle(dirFiles, language) : null;
+  const subtitleExt = subtitle?.match(/([^.]+$)/)?.[0];
+  const subtitleSourcePath = subtitle ? (0, import_path16.resolve)(entryPath, subtitle) : null;
+  const destSubtitleName = subtitle && subtitleExt ? `${folderName}.${subtitleExt}` : null;
+  if (useHardlink) {
+    (0, import_fs17.mkdirSync)(destFolder, { recursive: true });
+    const destVideoPath = (0, import_path16.resolve)(destFolder, destVideoName);
+    let mode;
+    try {
+      if (!sameDev2(videoSourcePath, destRoot)) throw new Error("cross-filesystem");
+      (0, import_fs17.linkSync)(videoSourcePath, destVideoPath);
+      mode = "hardlink";
+    } catch {
+      spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${folderName}`);
+      (0, import_fs17.cpSync)(videoSourcePath, destVideoPath);
+      mode = "copy";
+    }
+    if (subtitleSourcePath && destSubtitleName) (0, import_fs17.cpSync)(subtitleSourcePath, (0, import_path16.resolve)(destFolder, destSubtitleName));
+    recordImport(sessionId, entryPath, destFolder, mode);
+  } else {
+    if (isDir) {
+      const keep = new Set([videoFile, subtitle].filter(Boolean));
+      for (const f of dirFiles.filter((f2) => !keep.has(f2))) (0, import_fs17.rmSync)((0, import_path16.resolve)(entryPath, f), { recursive: true, force: true });
+      (0, import_fs17.renameSync)(videoSourcePath, (0, import_path16.resolve)(entryPath, destVideoName));
+      if (subtitleSourcePath && destSubtitleName) (0, import_fs17.renameSync)(subtitleSourcePath, (0, import_path16.resolve)(entryPath, destSubtitleName));
+      moveItem(entryPath, destFolder);
+    } else {
+      (0, import_fs17.mkdirSync)(destFolder, { recursive: true });
+      const destVideoPath = (0, import_path16.resolve)(destFolder, destVideoName);
+      if (sameDev2(videoSourcePath, destRoot)) {
+        (0, import_fs17.renameSync)(videoSourcePath, destVideoPath);
+      } else {
+        (0, import_fs17.cpSync)(videoSourcePath, destVideoPath);
+        (0, import_fs17.rmSync)(videoSourcePath);
+      }
+    }
+    recordImport(sessionId, entryPath, destFolder, "move");
+  }
+  spinner_default.succeed(`imported ${import_termkit18.Color.cyan.encoder(folderName)}`);
+};
+var watch = async ({ hardlink = false, verbose = false, auto = false }) => {
+  const config = getConfig();
+  if (config.sources.length === 0) throw new Error("no sources configured \u2014 run: reelsort config add source <dir>");
+  const language = config.language ?? "eng";
+  const pending = /* @__PURE__ */ new Map();
+  const handle = (path) => {
+    const existing = pending.get(path);
+    if (existing) clearTimeout(existing);
+    pending.set(
+      path,
+      setTimeout(async () => {
+        pending.delete(path);
+        try {
+          await processItem(path, hardlink, verbose, language, auto);
+        } catch (err) {
+          spinner_default.fail(`error processing ${path}: ${err.message}`);
+        }
+      }, 5e3)
+    );
+  };
+  const watcher = import_chokidar.default.watch(config.sources, {
+    depth: 0,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 5e3, pollInterval: 500 }
+  });
+  watcher.on("addDir", handle);
+  watcher.on("add", handle);
+  spinner_default.start();
+  spinner_default.succeed(`watching ${config.sources.length} source${config.sources.length !== 1 ? "s" : ""}`);
+  for (const s of config.sources) spinner_default.info(`  ${import_termkit18.Color.blue.encoder(s)}`);
+  spinner_default.stop();
+  process.stdin.resume();
+};
+var watch_default = watch;
+
+// package.json
+var version = "0.2.0";
+
+// src/program.ts
+var adapt = (fn) => (options) => fn(options);
+var { command, option } = import_termkit19.Program;
+var program = import_termkit19.Program.command("reelsort").version(version).description("a cli to manage media").commands([
+  command("config").description("manage configuration").commands([
+    command("source").description("manage source directories").commands([command("add", "<dir>").description("add a source directory").action(adapt(sourceAdd)), command("remove", "<dir>").description("remove a source directory").action(adapt(sourceRemove))]),
+    command("dest").description("manage destinations").commands([command("add", "<type> <dir>").description("set a destination (movie, tv, ps3)").action(adapt(destAdd)), command("remove", "<type>").description("remove a destination (movie, tv, ps3)").action(adapt(destRemove))]),
+    command("set", "<key> <subkey> [value]").description("set a value (e.g. set language eng)").action(adapt(configSet)),
+    command("show").description("show current configuration").action(adapt(configShow))
+  ]),
+  command("rename", "<dir>").description("rename media files in directory").options([option("t", "type", "<type>", "media type: movie, tv, ps3"), option("v", "verbose", null, "additional output")]).action(adapt(rename_default)),
+  command("reset", "<dir>").description("reset episode names (sxee)").options([option("d", "double", null, "episodes are doubles")]).action(adapt(reset_default)),
+  command("probe").description("index library metadata using ffprobe").options([option("t", "type", "<type>", "media type: movie, tv, ps3"), option("f", "force", null, "re-probe files already indexed"), option("v", "verbose", null, "show each file as it is probed")]).action(adapt(probe_default)),
+  command("list").description("list library contents").options([option("t", "type", "<type>", "media type: movie, tv, ps3"), option("m", "missing-subs", null, "only show items without subtitles"), option("c", "codec", "<codec>", "filter by codec (e.g. x265)"), option("r", "resolution", "<res>", "filter by resolution (e.g. 1080p, 4K)"), option("s", "sort", "<field>", "sort by: year (default), title")]).action(adapt(list_default)),
+  command("watch").description("watch sources and auto-import new media").options([option("H", "hardlink", null, "hardlink instead of moving (falls back to copy across filesystems)"), option("v", "verbose", null, "additional output"), option("a", "auto", null, "auto-register unrecognised TV shows instead of skipping them")]).action(adapt(watch_default)),
+  command("scan").description("import media from configured sources to destinations").options([option("t", "type", "<type>", "only process this media type: movie, tv, ps3"), option("H", "hardlink", null, "hardlink instead of moving (falls back to copy across filesystems)"), option("n", "dry-run", null, "show what would be imported without doing it"), option("v", "verbose", null, "additional output"), option("a", "auto", null, "auto-register unrecognised TV shows instead of skipping them")]).action(adapt(scan_default)),
+  command("clean").description("remove source files that have already been imported").options([option("n", "dry-run", null, "show what would be removed without doing it"), option("o", "older-than", "<age>", "only clean imports older than age (e.g. 14d, 6h, 30m)")]).action(adapt(clean_default)),
+  command("undo").description("undo the last rename session").action(adapt(undo_default)),
+  command("history").description("show rename or import history").options([option("l", "limit", "<n>", "number of sessions to show (default 10)"), option("i", "imports", null, "show import history instead of rename history")]).action(adapt(history_default)),
+  command("diff", "<dir1> <dir2>").description("compare differences between two directories").options([option("o", "only", "[ext...]", "check specified extensions"), option("i", "ignore", "[ext...]", "ignore specified extensions")]).action(adapt(differences_default)),
+  command("missing").description("show missing episodes for TV shows (requires TMDb key)").options([option("s", "show", "<name>", "check a specific show instead of all")]).action(adapt(missing_default)),
+  command("shows").description("list all registered TV shows with TMDb status and size").action(adapt(shows_default)),
+  command("stats").description("show library statistics").action(adapt(stats_default)),
+  command("link").description("link TV shows to TMDb (retroactively or after manual library setup)").options([option("f", "force", null, "re-link shows that are already linked")]).action(adapt(link_default)),
+  command("ended").description("mark a show as ended (excluded from reelsort missing)").options([option("r", "remove", null, "restore an ended show to active")]).action(adapt(ended_default)),
+  command("add", "<name>").description("add a TV show by name \u2014 searches TMDb and registers it for scanning").action(adapt(add_default))
+]);
+var program_default = program;
+
+// src/cli.ts
+var run = async (args) => {
+  try {
+    await program_default.parse(args);
+  } catch (err) {
+    spinner_default.fail(err.message);
+    spinner_default.stop();
+  }
+  process.exit();
+};
+run(process.argv);