reelsort 0.1.0

package/dist/index.js

@@ -0,0 +1,1842 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_EPISODE_FORMAT: () => DEFAULT_EPISODE_FORMAT,
+  DEFAULT_MOVIE_FORMAT: () => DEFAULT_MOVIE_FORMAT,
+  DEFAULT_SEASON_FORMAT: () => DEFAULT_SEASON_FORMAT,
+  clean: () => clean_default,
+  configAdd: () => configAdd,
+  configRemove: () => configRemove,
+  configSet: () => configSet,
+  configShow: () => configShow,
+  deleteImport: () => deleteImport,
+  deleteSession: () => deleteSession,
+  detectEdition: () => detectEdition,
+  differences: () => differences_default,
+  formatEpisode: () => formatEpisode,
+  formatMovieName: () => formatMovieName,
+  formatSeasonFolder: () => formatSeasonFolder,
+  getCleanableImports: () => getCleanableImports,
+  getConfig: () => getConfig,
+  getHistory: () => getHistory,
+  getImportByDest: () => getImportByDest,
+  getLastSession: () => getLastSession,
+  getMediaInfo: () => getMediaInfo,
+  history: () => history_default,
+  list: () => list_default,
+  normalizeCodec: () => normalizeCodec,
+  normalizeResolution: () => normalizeResolution,
+  parseDownloadName: () => parseDownloadName,
+  parseQuality: () => parseQuality,
+  probe: () => probe_default,
+  recordImport: () => recordImport,
+  recordRename: () => recordRename,
+  rename: () => rename_default,
+  reset: () => reset_default,
+  saveConfig: () => saveConfig,
+  scan: () => scan_default,
+  titleCase: () => titleCase_default,
+  undo: () => undo_default,
+  upsertMediaInfo: () => upsertMediaInfo,
+  videoExtensions: () => videoExtensions_default,
+  watch: () => watch_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/actions/config.ts
+var import_cosmetic = __toESM(require("cosmetic"));
+var import_path2 = require("path");
+
+// 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/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/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/refs/spinner.ts
+var import_termpulse = require("termpulse");
+var Spinner = class {
+  spinner;
+  _isSpinning = false;
+  _text = "";
+  constructor() {
+    this.spinner = new import_termpulse.Spinner();
+  }
+  get text() {
+    return this._text;
+  }
+  set text(t) {
+    this._text = t;
+    if (this._isSpinning) this.spinner.message(t);
+  }
+  get isSpinning() {
+    return this._isSpinning;
+  }
+  start(s) {
+    if (s) this._text = s;
+    this.spinner.start();
+    this._isSpinning = true;
+    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();
+    this._isSpinning = false;
+    process.stdin.resume();
+    return this;
+  }
+};
+var spinner_default = new Spinner();
+
+// src/actions/config.ts
+var DEST_TYPES = ["movie", "tv", "ps3"];
+var configAdd = async ({ key, value }) => {
+  if (key !== "source") throw new Error(`unknown key '${key}', expected: source`);
+  const dir = (0, import_path2.resolve)(value);
+  const config = getConfig();
+  if (config.sources.includes(dir)) {
+    spinner_default.start();
+    spinner_default.info(`source already configured: ${import_cosmetic.default.blue.encoder(dir)}`);
+    spinner_default.stop();
+    return;
+  }
+  config.sources.push(dir);
+  saveConfig(config);
+  spinner_default.start();
+  spinner_default.succeed(`added source: ${import_cosmetic.default.blue.encoder(dir)}`);
+  spinner_default.stop();
+};
+var configRemove = async ({ key, value }) => {
+  if (key !== "source") throw new Error(`unknown key '${key}', expected: source`);
+  const dir = (0, import_path2.resolve)(value);
+  const config = getConfig();
+  const index = config.sources.indexOf(dir);
+  if (index === -1) {
+    spinner_default.start();
+    spinner_default.warn(`source not found: ${import_cosmetic.default.blue.encoder(dir)}`);
+    spinner_default.stop();
+    return;
+  }
+  config.sources.splice(index, 1);
+  saveConfig(config);
+  spinner_default.start();
+  spinner_default.succeed(`removed source: ${import_cosmetic.default.blue.encoder(dir)}`);
+  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_cosmetic.default.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_cosmetic.default.cyan.encoder(value ?? subkey)}`);
+    spinner_default.stop();
+    return;
+  }
+  if (key !== "dest") throw new Error(`unknown key '${key}', expected: dest, language, tmdb-key, format`);
+  if (!DEST_TYPES.includes(subkey)) {
+    throw new Error(`unknown type '${subkey}', expected: ${DEST_TYPES.join(", ")}`);
+  }
+  if (!value) throw new Error(`missing path for dest ${subkey}`);
+  const dir = (0, import_path2.resolve)(value);
+  config.dest[subkey] = dir;
+  saveConfig(config);
+  spinner_default.start();
+  spinner_default.succeed(`set ${subkey} destination: ${import_cosmetic.default.cyan.encoder(dir)}`);
+  spinner_default.stop();
+};
+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_cosmetic.default.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_cosmetic.default.cyan.encoder(path)}`);
+    }
+  }
+  console.log(`
+Subtitle language: ${import_cosmetic.default.cyan.encoder(config.language ?? "eng (default)")}`);
+  console.log(`TMDb API key:      ${config.tmdbApiKey ? import_cosmetic.default.green.encoder("configured") : import_cosmetic.default.red.encoder("not set")}`);
+  console.log(`Movie format:      ${import_cosmetic.default.cyan.encoder(config.format?.movie ?? DEFAULT_MOVIE_FORMAT + " (default)")}`);
+  console.log(`Episode format:    ${import_cosmetic.default.cyan.encoder(config.format?.episode ?? DEFAULT_EPISODE_FORMAT + " (default)")}`);
+  console.log(`Season folder:     ${import_cosmetic.default.cyan.encoder(config.format?.season ?? DEFAULT_SEASON_FORMAT + " (default)")}`);
+  console.log();
+};
+
+// src/actions/probe.ts
+var import_cosmetic2 = __toESM(require("cosmetic"));
+var import_child_process = require("child_process");
+var import_fs3 = require("fs");
+var import_path4 = require("path");
+
+// src/db.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+var import_fs2 = require("fs");
+var import_os2 = require("os");
+var import_path3 = require("path");
+var DB_DIR = (0, import_path3.join)((0, import_os2.homedir)(), ".config", "reelsort");
+var DB_PATH = (0, import_path3.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 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 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/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/probe.ts
+var DEST_TYPES2 = ["movie", "tv", "ps3"];
+var CODEC_MAP = {
+  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_MAP[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_fs3.existsSync)(dir) || depth > maxDepth) return [];
+  const results = [];
+  for (const entry of (0, import_fs3.readdirSync)(dir)) {
+    const entryPath = (0, import_path4.resolve)(dir, entry);
+    try {
+      if ((0, import_fs3.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_TYPES2).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_fs3.existsSync)(destRoot)) continue;
+    spinner_default.text = `scanning ${import_cosmetic2.default.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_cosmetic2.default.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/list.ts
+var import_cosmetic3 = __toESM(require("cosmetic"));
+var import_fs5 = require("fs");
+var import_path6 = require("path");
+
+// src/helpers/dirSize.ts
+var import_fs4 = require("fs");
+var import_path5 = require("path");
+var dirSize = (dir) => {
+  let total = 0;
+  try {
+    for (const entry of (0, import_fs4.readdirSync)(dir, { withFileTypes: true })) {
+      const full = (0, import_path5.resolve)(dir, entry.name);
+      if (entry.isDirectory()) {
+        total += dirSize(full);
+      } else if (entry.isFile()) {
+        try {
+          total += (0, import_fs4.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_MAP2 = {
+  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_MAP2[token]) codec = CODEC_MAP2[token];
+    if (resolution && codec) break;
+  }
+  return { resolution, codec };
+};
+var normalizeResolution = (s) => RESOLUTION_MAP[s.toLowerCase()] ?? s;
+var normalizeCodec = (s) => CODEC_MAP2[s.toLowerCase()] ?? s;
+
+// src/refs/subtitleExtensions.json
+var subtitleExtensions_default = ["srt", "sub", "idx", "ass", "ssa", "vtt", "sup"];
+
+// src/actions/list.ts
+var DEST_TYPES3 = ["movie", "tv", "ps3"];
+var findVideoFile = (dir) => {
+  try {
+    return (0, import_fs5.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_fs5.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 col = (s, width) => s.padEnd(width).substring(0, width);
+var list = async ({ type, missingSubs, codec: codecFilter, resolution: resFilter, sort }) => {
+  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>");
+  for (const t of types) {
+    const destRoot = config.dest[t];
+    if (!(0, import_fs5.existsSync)(destRoot)) {
+      console.log(`
+${t.toUpperCase()}  ${import_cosmetic3.default.blue.encoder(destRoot)}  (not found)`);
+      continue;
+    }
+    const folders = (0, import_fs5.readdirSync)(destRoot).filter((f) => {
+      try {
+        return (0, import_fs5.lstatSync)((0, import_path6.resolve)(destRoot, f)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    const entries = folders.map((folder) => {
+      const folderPath = (0, import_path6.resolve)(destRoot, folder);
+      const parsed = parseLibraryFolder(folder);
+      const videoFile = findVideoFile(folderPath);
+      const mediaInfo = videoFile ? getMediaInfo((0, import_path6.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);
+    });
+    const titleW = Math.min(50, Math.max(10, ...filtered.map((e) => e.title.length)) + 2);
+    const divider = "\u2500".repeat(titleW + 44);
+    console.log(`
+${import_cosmetic3.default.yellow.encoder(t.toUpperCase())}  ${import_cosmetic3.default.blue.encoder(destRoot)}`);
+    console.log(divider);
+    console.log(`${"Title".padEnd(titleW)}  ${"Year".padEnd(6)}  ${"Res".padEnd(6)}  ${"Codec".padEnd(6)}  ${"Size".padEnd(10)}  Sub`);
+    console.log(divider);
+    for (const e of filtered) {
+      const sub = e.hasSub ? import_cosmetic3.default.green.encoder("\u2713") : import_cosmetic3.default.red.encoder("\u2717");
+      console.log(
+        `${col(e.title, titleW)}  ${col(e.year?.toString() ?? "\u2014", 6)}  ${col(e.resolution ?? "\u2014", 6)}  ${col(e.codec ?? "\u2014", 6)}  ${col(e.size, 10)}  ${sub}`
+      );
+    }
+    console.log(divider);
+    console.log(`${filtered.length} of ${entries.length} item${entries.length !== 1 ? "s" : ""}`);
+  }
+  console.log();
+};
+var list_default = list;
+
+// 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/actions/watch.ts
+var import_chokidar = __toESM(require("chokidar"));
+var import_cosmetic4 = __toESM(require("cosmetic"));
+var import_fs6 = require("fs");
+var import_path7 = require("path");
+
+// 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/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/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 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/actions/watch.ts
+var sameDev = (a, b) => {
+  try {
+    let bExisting = b;
+    while (!(0, import_fs6.existsSync)(bExisting)) bExisting = (0, import_path7.dirname)(bExisting);
+    return (0, import_fs6.statSync)(a).dev === (0, import_fs6.statSync)(bExisting).dev;
+  } catch {
+    return false;
+  }
+};
+var moveItem = (src, dest) => {
+  if (sameDev(src, dest)) {
+    (0, import_fs6.renameSync)(src, dest);
+  } else {
+    (0, import_fs6.cpSync)(src, dest, { recursive: true });
+    (0, import_fs6.rmSync)(src, { recursive: true, force: true });
+  }
+};
+var findVideo = (dir) => (0, import_fs6.readdirSync)(dir).find((f) => {
+  const ext = f.match(/([^.]+$)/)?.[0];
+  return ext && videoExtensions_default.includes(ext);
+}) ?? null;
+var findSeasonFolder = (showPath, season) => {
+  if (!(0, import_fs6.existsSync)(showPath)) return null;
+  const folders = (0, import_fs6.readdirSync)(showPath).filter((f) => {
+    try {
+      return (0, import_fs6.lstatSync)((0, import_path7.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_path7.basename)(entryPath);
+  const movieFormat = config.format?.movie ?? DEFAULT_MOVIE_FORMAT;
+  const seasonFormat = config.format?.season ?? DEFAULT_SEASON_FORMAT;
+  const isDir = (0, import_fs6.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_path7.resolve)(destRoot, destName);
+    if ((0, import_fs6.existsSync)(destPath)) {
+      spinner_default.warn(`already exists: ${destName}`);
+      return;
+    }
+    moveItem(entryPath, destPath);
+    recordImport(sessionId, entryPath, destPath, "move");
+    spinner_default.succeed(`imported ${import_cosmetic4.default.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_path7.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 = findSeasonFolder(showPath, parsed.season) ?? formatSeasonFolder(seasonFormat, parsed.season);
+    const seasonPath = (0, import_path7.resolve)(showPath, seasonFolderName);
+    const videoFile2 = isDir ? findVideo(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_path7.resolve)(seasonPath, destVideoName2);
+    const videoSourcePath2 = isDir ? (0, import_path7.resolve)(entryPath, videoFile2) : entryPath;
+    if ((0, import_fs6.existsSync)(destVideoPath)) {
+      spinner_default.warn(`already exists: ${episodeName}`);
+      return;
+    }
+    const dirFiles2 = isDir ? (0, import_fs6.readdirSync)(entryPath) : [];
+    const subtitle2 = isDir ? findSubtitle(dirFiles2, language) : null;
+    const subtitleExt2 = subtitle2?.match(/([^.]+$)/)?.[0];
+    const subtitleSourcePath2 = subtitle2 ? (0, import_path7.resolve)(entryPath, subtitle2) : null;
+    const destSubtitleName2 = subtitle2 && subtitleExt2 ? `${episodeName}.${subtitleExt2}` : null;
+    (0, import_fs6.mkdirSync)(seasonPath, { recursive: true });
+    let mode = "move";
+    if (useHardlink) {
+      try {
+        if (!sameDev(videoSourcePath2, seasonPath)) throw new Error("cross-filesystem");
+        (0, import_fs6.linkSync)(videoSourcePath2, destVideoPath);
+        mode = "hardlink";
+      } catch {
+        spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${episodeName}`);
+        (0, import_fs6.cpSync)(videoSourcePath2, destVideoPath);
+        mode = "copy";
+      }
+      if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs6.cpSync)(subtitleSourcePath2, (0, import_path7.resolve)(seasonPath, destSubtitleName2));
+    } else {
+      if (sameDev(videoSourcePath2, seasonPath)) {
+        (0, import_fs6.renameSync)(videoSourcePath2, destVideoPath);
+      } else {
+        (0, import_fs6.cpSync)(videoSourcePath2, destVideoPath);
+        (0, import_fs6.rmSync)(videoSourcePath2);
+      }
+      if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs6.renameSync)(subtitleSourcePath2, (0, import_path7.resolve)(seasonPath, destSubtitleName2));
+      if (isDir) (0, import_fs6.rmSync)(entryPath, { recursive: true, force: true });
+    }
+    recordImport(sessionId, entryPath, seasonPath, mode);
+    spinner_default.succeed(`imported ${import_cosmetic4.default.cyan.encoder(`${showFolderName} / ${seasonFolderName} / ${episodeName}`)}`);
+    return;
+  }
+  const edition = detectEdition(entry);
+  const folderName = formatMovieName(movieFormat, parsed.title, parsed.year, edition);
+  const destFolder = (0, import_path7.resolve)(destRoot, folderName);
+  if ((0, import_fs6.existsSync)(destFolder)) {
+    spinner_default.warn(`already exists: ${folderName}`);
+    return;
+  }
+  const videoFile = isDir ? findVideo(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_path7.resolve)(entryPath, videoFile) : entryPath;
+  const dirFiles = isDir ? (0, import_fs6.readdirSync)(entryPath) : [];
+  const subtitle = isDir ? findSubtitle(dirFiles, language) : null;
+  const subtitleExt = subtitle?.match(/([^.]+$)/)?.[0];
+  const subtitleSourcePath = subtitle ? (0, import_path7.resolve)(entryPath, subtitle) : null;
+  const destSubtitleName = subtitle && subtitleExt ? `${folderName}.${subtitleExt}` : null;
+  if (useHardlink) {
+    (0, import_fs6.mkdirSync)(destFolder, { recursive: true });
+    const destVideoPath = (0, import_path7.resolve)(destFolder, destVideoName);
+    let mode;
+    try {
+      if (!sameDev(videoSourcePath, destRoot)) throw new Error("cross-filesystem");
+      (0, import_fs6.linkSync)(videoSourcePath, destVideoPath);
+      mode = "hardlink";
+    } catch {
+      spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${folderName}`);
+      (0, import_fs6.cpSync)(videoSourcePath, destVideoPath);
+      mode = "copy";
+    }
+    if (subtitleSourcePath && destSubtitleName) (0, import_fs6.cpSync)(subtitleSourcePath, (0, import_path7.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_fs6.rmSync)((0, import_path7.resolve)(entryPath, f), { recursive: true, force: true });
+      (0, import_fs6.renameSync)(videoSourcePath, (0, import_path7.resolve)(entryPath, destVideoName));
+      if (subtitleSourcePath && destSubtitleName) (0, import_fs6.renameSync)(subtitleSourcePath, (0, import_path7.resolve)(entryPath, destSubtitleName));
+      moveItem(entryPath, destFolder);
+    } else {
+      (0, import_fs6.mkdirSync)(destFolder, { recursive: true });
+      const destVideoPath = (0, import_path7.resolve)(destFolder, destVideoName);
+      if (sameDev(videoSourcePath, destRoot)) {
+        (0, import_fs6.renameSync)(videoSourcePath, destVideoPath);
+      } else {
+        (0, import_fs6.cpSync)(videoSourcePath, destVideoPath);
+        (0, import_fs6.rmSync)(videoSourcePath);
+      }
+    }
+    recordImport(sessionId, entryPath, destFolder, "move");
+  }
+  spinner_default.succeed(`imported ${import_cosmetic4.default.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_cosmetic4.default.blue.encoder(s)}`);
+  spinner_default.stop();
+  process.stdin.resume();
+};
+var watch_default = watch;
+
+// src/actions/clean.ts
+var import_cosmetic5 = __toESM(require("cosmetic"));
+var import_fs7 = require("fs");
+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_fs7.existsSync)(imp.sourcePath)) {
+      if (!dryRun) deleteImport(imp.id);
+      continue;
+    }
+    if (dryRun) {
+      spinner_default.succeed(`[dry] would remove ${import_cosmetic5.default.blue.encoder(imp.sourcePath)}`);
+      cleaned++;
+      continue;
+    }
+    try {
+      (0, import_fs7.rmSync)(imp.sourcePath, { recursive: true, force: true });
+      deleteImport(imp.id);
+      spinner_default.succeed(`removed ${import_cosmetic5.default.blue.encoder(imp.sourcePath)}`);
+      cleaned++;
+    } catch {
+      spinner_default.warn(`locked or inaccessible, skipped: ${import_cosmetic5.default.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/scan.ts
+var import_cosmetic6 = __toESM(require("cosmetic"));
+var import_fs8 = require("fs");
+var import_path8 = require("path");
+var import_termpulse2 = require("termpulse");
+
+// src/helpers/hyperlink.ts
+var hyperlink = (url, text) => `\x1B]8;;${url}\x1B\\${text}\x1B]8;;\x1B\\`;
+
+// src/actions/scan.ts
+var sameDev2 = (a, b) => {
+  try {
+    let bExisting = b;
+    while (!(0, import_fs8.existsSync)(bExisting)) bExisting = (0, import_path8.dirname)(bExisting);
+    return (0, import_fs8.statSync)(a).dev === (0, import_fs8.statSync)(bExisting).dev;
+  } catch {
+    return false;
+  }
+};
+var moveFolder = (src, dest) => {
+  if (sameDev2(src, dest)) {
+    (0, import_fs8.renameSync)(src, dest);
+  } else {
+    (0, import_fs8.cpSync)(src, dest, { recursive: true });
+    (0, import_fs8.rmSync)(src, { recursive: true, force: true });
+  }
+};
+var findVideo2 = (dir) => (0, import_fs8.readdirSync)(dir).find((f) => {
+  const ext = f.match(/([^.]+$)/)?.[0];
+  return ext && videoExtensions_default.includes(ext);
+}) ?? null;
+var findSeasonFolder2 = (showPath, season) => {
+  if (!(0, import_fs8.existsSync)(showPath)) return null;
+  const folders = (0, import_fs8.readdirSync)(showPath).filter((f) => {
+    try {
+      return (0, import_fs8.lstatSync)((0, import_path8.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_fs8.existsSync)(source)) {
+      spinner_default.warn(`source not found: ${import_cosmetic6.default.blue.encoder(source)}`);
+      continue;
+    }
+    spinner_default.text = `scanning ${import_cosmetic6.default.blue.encoder(source)}`;
+    for (const entry of (0, import_fs8.readdirSync)(source)) {
+      const entryPath = (0, import_path8.resolve)(source, entry);
+      const isDir = (0, import_fs8.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_path8.resolve)(destRoot, destName);
+        if ((0, import_fs8.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_termpulse2.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_path8.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 = findSeasonFolder2(showPath, parsed.season) ?? formatSeasonFolder(seasonFormat, parsed.season);
+        const seasonPath = (0, import_path8.resolve)(showPath, seasonFolderName);
+        const videoFile2 = isDir ? findVideo2(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_path8.resolve)(seasonPath, destVideoName2);
+        const videoSourcePath2 = isDir ? (0, import_path8.resolve)(entryPath, videoFile2) : entryPath;
+        if ((0, import_fs8.existsSync)(destVideoPath)) {
+          spinner_default.warn(`already exists: ${episodeName}`);
+          skipped++;
+          continue;
+        }
+        const dirFiles2 = isDir ? (0, import_fs8.readdirSync)(entryPath) : [];
+        const subtitle2 = isDir ? findSubtitle(dirFiles2, language) : null;
+        const subtitleExt2 = subtitle2?.match(/([^.]+$)/)?.[0];
+        const subtitleSourcePath2 = subtitle2 ? (0, import_path8.resolve)(entryPath, subtitle2) : null;
+        const destSubtitleName2 = subtitle2 && subtitleExt2 ? `${episodeName}.${subtitleExt2}` : null;
+        if (!dryRun) {
+          (0, import_fs8.mkdirSync)(seasonPath, { recursive: true });
+          let mode = "move";
+          if (useHardlink) {
+            try {
+              if (!sameDev2(videoSourcePath2, seasonPath)) throw new Error("cross-filesystem");
+              (0, import_fs8.linkSync)(videoSourcePath2, destVideoPath);
+              mode = "hardlink";
+            } catch {
+              spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${episodeName}`);
+              (0, import_fs8.cpSync)(videoSourcePath2, destVideoPath);
+              mode = "copy";
+            }
+            if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs8.cpSync)(subtitleSourcePath2, (0, import_path8.resolve)(seasonPath, destSubtitleName2));
+          } else {
+            if (sameDev2(videoSourcePath2, seasonPath)) {
+              (0, import_fs8.renameSync)(videoSourcePath2, destVideoPath);
+            } else {
+              (0, import_fs8.cpSync)(videoSourcePath2, destVideoPath);
+              (0, import_fs8.rmSync)(videoSourcePath2);
+            }
+            if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs8.renameSync)(subtitleSourcePath2, (0, import_path8.resolve)(seasonPath, destSubtitleName2));
+            if (isDir) (0, import_fs8.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_path8.resolve)(destRoot, folderName);
+      if ((0, import_fs8.existsSync)(destFolder)) {
+        spinner_default.warn(`already exists: ${folderName}`);
+        skipped++;
+        continue;
+      }
+      const videoFile = isDir ? findVideo2(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_path8.resolve)(entryPath, videoFile) : entryPath;
+      const dirFiles = isDir ? (0, import_fs8.readdirSync)(entryPath) : [];
+      const subtitle = isDir ? findSubtitle(dirFiles, language) : null;
+      const subtitleExt = subtitle?.match(/([^.]+$)/)?.[0];
+      const subtitleSourcePath = subtitle ? (0, import_path8.resolve)(entryPath, subtitle) : null;
+      const destSubtitleName = subtitle && subtitleExt ? `${folderName}.${subtitleExt}` : null;
+      if (!dryRun) {
+        if (useHardlink) {
+          (0, import_fs8.mkdirSync)(destFolder, { recursive: true });
+          const destVideoPath = (0, import_path8.resolve)(destFolder, destVideoName);
+          let mode;
+          try {
+            if (!sameDev2(videoSourcePath, destRoot)) throw new Error("cross-filesystem");
+            (0, import_fs8.linkSync)(videoSourcePath, destVideoPath);
+            mode = "hardlink";
+          } catch {
+            spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${folderName}`);
+            (0, import_fs8.cpSync)(videoSourcePath, destVideoPath);
+            mode = "copy";
+          }
+          if (subtitleSourcePath && destSubtitleName) (0, import_fs8.cpSync)(subtitleSourcePath, (0, import_path8.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_fs8.rmSync)((0, import_path8.resolve)(entryPath, f), { recursive: true, force: true });
+            (0, import_fs8.renameSync)(videoSourcePath, (0, import_path8.resolve)(entryPath, destVideoName));
+            if (subtitleSourcePath && destSubtitleName) (0, import_fs8.renameSync)(subtitleSourcePath, (0, import_path8.resolve)(entryPath, destSubtitleName));
+            moveFolder(entryPath, destFolder);
+          } else {
+            (0, import_fs8.mkdirSync)(destFolder, { recursive: true });
+            const destVideoPath = (0, import_path8.resolve)(destFolder, destVideoName);
+            if (sameDev2(videoSourcePath, destRoot)) {
+              (0, import_fs8.renameSync)(videoSourcePath, destVideoPath);
+            } else {
+              (0, import_fs8.cpSync)(videoSourcePath, destVideoPath);
+              (0, import_fs8.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/history.ts
+var import_cosmetic7 = __toESM(require("cosmetic"));
+var import_path9 = require("path");
+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_cosmetic7.default.yellow.encoder(label)}  (${session.records.length} item${session.records.length !== 1 ? "s" : ""})`);
+      for (const r of session.records) {
+        const src = (0, import_path9.basename)(r.sourcePath);
+        const dest = import_cosmetic7.default.cyan.encoder(r.destinationPath);
+        const mode = r.mode !== "move" ? ` ${import_cosmetic7.default.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_path9.extname)(r.newPath) === "");
+      console.log(`
+${import_cosmetic7.default.yellow.encoder(label)}  (${folders.length} item${folders.length !== 1 ? "s" : ""})`);
+      for (const r of folders) {
+        const oldName = (0, import_path9.basename)(r.oldPath);
+        const newName = (0, import_path9.basename)(r.newPath);
+        console.log(`  ${import_cosmetic7.default.blue.encoder(oldName)}  \u2192  ${import_cosmetic7.default.cyan.encoder(newName)}`);
+      }
+    }
+  }
+  console.log();
+};
+var history_default = history;
+
+// src/actions/undo.ts
+var import_cosmetic8 = __toESM(require("cosmetic"));
+var import_fs9 = require("fs");
+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_fs9.renameSync)(record.newPath, record.oldPath);
+    spinner_default.succeed(`${import_cosmetic8.default.cyan.encoder(record.newPath)} \u2192 ${import_cosmetic8.default.blue.encoder(record.oldPath)}`);
+    undone++;
+  }
+  deleteSession(records[0].sessionId);
+  spinner_default.succeed(`undid ${undone} renames`);
+  spinner_default.stop();
+};
+var undo_default = undo;
+
+// src/actions/differences.ts
+var import_cosmetic9 = __toESM(require("cosmetic"));
+var import_fs10 = require("fs");
+var import_path10 = require("path");
+var differences = async ({ dir1: rawDir1, dir2: rawDir2, only, ignore }) => {
+  let dir1 = rawDir1;
+  let dir2 = rawDir2;
+  spinner_default.text = `checking differences between ${import_cosmetic9.default.blue.encoder(dir1)} and ${import_cosmetic9.default.blue.encoder(dir2)}`;
+  spinner_default.start();
+  dir1 = (0, import_path10.resolve)(dir1);
+  dir2 = (0, import_path10.resolve)(dir2);
+  if (!(0, import_fs10.existsSync)(dir1)) throw new Error(`dir1 ${dir1} does not exist`);
+  if (!(0, import_fs10.existsSync)(dir2)) throw new Error(`dir2 ${dir2} does not exist`);
+  let list1 = (0, import_fs10.readdirSync)(dir1);
+  let list2 = (0, import_fs10.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_cosmetic9.default.blue.encoder(dir1)} and ${import_cosmetic9.default.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_cosmetic9.default.green.encoder("added")} ${i}`);
+  for (const i of removed) console.log(`${import_cosmetic9.default.red.encoder("removed")} ${i}`);
+};
+var differences_default = differences;
+
+// src/actions/rename.ts
+var import_cosmetic10 = __toESM(require("cosmetic"));
+var import_fs11 = require("fs");
+var import_path11 = require("path");
+var import_rimraf = require("rimraf");
+var rename = async ({ dir: inputDir, type, verbose }) => {
+  const dir = (0, import_path11.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_cosmetic10.default.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_cosmetic10.default.blue.encoder(dir)} ${index + 1}/${list2.length}`;
+    if (!(0, import_fs11.lstatSync)((0, import_path11.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_path11.resolve)(dir, entry);
+      const ps3New = (0, import_path11.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_path11.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_path11.resolve)(dir, entry, f));
+      removed++;
+    }
+    const fileOld = (0, import_path11.resolve)(dir, entry, video);
+    const fileNew = (0, import_path11.resolve)(dir, entry, `${formatted}.${ext}`);
+    const folderOld = (0, import_path11.resolve)(dir, entry);
+    const folderNew = (0, import_path11.resolve)(dir, formatted);
+    (0, import_fs11.renameSync)(fileOld, fileNew);
+    if (subtitle && subtitleExt) {
+      (0, import_fs11.renameSync)((0, import_path11.resolve)(dir, entry, subtitle), (0, import_path11.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_cosmetic10.default.cyan.encoder(dir)}`);
+  spinner_default.stop();
+};
+var rename_default = rename;
+
+// src/actions/reset.ts
+var import_cosmetic11 = __toESM(require("cosmetic"));
+var import_fs12 = require("fs");
+var import_path12 = require("path");
+var reset = async ({ dir: inputDir, double }) => {
+  let dir = inputDir;
+  spinner_default.text = `resetting episodes in ${import_cosmetic11.default.blue.encoder(dir)}`;
+  spinner_default.start();
+  dir = (0, import_path12.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_path12.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_path12.basename)((0, import_path12.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_cosmetic11.default.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_path12.resolve)(dir, i), (0, import_path12.resolve)(dir, name));
+    renamed++;
+  }
+  spinner_default.succeed(`renamed ${renamed} files`);
+  spinner_default.info(`skipped ${skipped} files`);
+  spinner_default.succeed(`done in ${import_cosmetic11.default.cyan.encoder(dir)}`);
+  spinner_default.stop();
+};
+var reset_default = reset;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_EPISODE_FORMAT,
+  DEFAULT_MOVIE_FORMAT,
+  DEFAULT_SEASON_FORMAT,
+  clean,
+  configAdd,
+  configRemove,
+  configSet,
+  configShow,
+  deleteImport,
+  deleteSession,
+  detectEdition,
+  differences,
+  formatEpisode,
+  formatMovieName,
+  formatSeasonFolder,
+  getCleanableImports,
+  getConfig,
+  getHistory,
+  getImportByDest,
+  getLastSession,
+  getMediaInfo,
+  history,
+  list,
+  normalizeCodec,
+  normalizeResolution,
+  parseDownloadName,
+  parseQuality,
+  probe,
+  recordImport,
+  recordRename,
+  rename,
+  reset,
+  saveConfig,
+  scan,
+  titleCase,
+  undo,
+  upsertMediaInfo,
+  videoExtensions,
+  watch
+});