reelsort 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1767 @@
+// src/actions/config.ts
+import cosmetic from "cosmetic";
+import { resolve } from "path";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".config", "reelsort");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+var getConfig = () => {
+  if (!existsSync(CONFIG_PATH)) return { sources: [], dest: {} };
+  return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+};
+var saveConfig = (config) => {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  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
+import { Spinner as TermSpinner } from "termpulse";
+var Spinner = class {
+  spinner;
+  _isSpinning = false;
+  _text = "";
+  constructor() {
+    this.spinner = new TermSpinner();
+  }
+  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 = resolve(value);
+  const config = getConfig();
+  if (config.sources.includes(dir)) {
+    spinner_default.start();
+    spinner_default.info(`source already configured: ${cosmetic.blue.encoder(dir)}`);
+    spinner_default.stop();
+    return;
+  }
+  config.sources.push(dir);
+  saveConfig(config);
+  spinner_default.start();
+  spinner_default.succeed(`added source: ${cosmetic.blue.encoder(dir)}`);
+  spinner_default.stop();
+};
+var configRemove = async ({ key, value }) => {
+  if (key !== "source") throw new Error(`unknown key '${key}', expected: source`);
+  const dir = resolve(value);
+  const config = getConfig();
+  const index = config.sources.indexOf(dir);
+  if (index === -1) {
+    spinner_default.start();
+    spinner_default.warn(`source not found: ${cosmetic.blue.encoder(dir)}`);
+    spinner_default.stop();
+    return;
+  }
+  config.sources.splice(index, 1);
+  saveConfig(config);
+  spinner_default.start();
+  spinner_default.succeed(`removed source: ${cosmetic.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: ${cosmetic.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: ${cosmetic.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 = resolve(value);
+  config.dest[subkey] = dir;
+  saveConfig(config);
+  spinner_default.start();
+  spinner_default.succeed(`set ${subkey} destination: ${cosmetic.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(`  ${cosmetic.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)}  ${cosmetic.cyan.encoder(path)}`);
+    }
+  }
+  console.log(`
+Subtitle language: ${cosmetic.cyan.encoder(config.language ?? "eng (default)")}`);
+  console.log(`TMDb API key:      ${config.tmdbApiKey ? cosmetic.green.encoder("configured") : cosmetic.red.encoder("not set")}`);
+  console.log(`Movie format:      ${cosmetic.cyan.encoder(config.format?.movie ?? DEFAULT_MOVIE_FORMAT + " (default)")}`);
+  console.log(`Episode format:    ${cosmetic.cyan.encoder(config.format?.episode ?? DEFAULT_EPISODE_FORMAT + " (default)")}`);
+  console.log(`Season folder:     ${cosmetic.cyan.encoder(config.format?.season ?? DEFAULT_SEASON_FORMAT + " (default)")}`);
+  console.log();
+};
+
+// src/actions/probe.ts
+import cosmetic2 from "cosmetic";
+import { spawnSync } from "child_process";
+import { existsSync as existsSync3, lstatSync, readdirSync } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/db.ts
+import Database from "better-sqlite3";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var DB_DIR = join2(homedir2(), ".config", "reelsort");
+var DB_PATH = join2(DB_DIR, "reelsort.db");
+var _db = null;
+var db = () => {
+  if (_db) return _db;
+  if (!existsSync2(DB_DIR)) mkdirSync2(DB_DIR, { recursive: true });
+  _db = new Database(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 = spawnSync("ffprobe", ["-version"], { encoding: "utf-8" });
+  return !result.error && result.status === 0;
+};
+var runFfprobe = (filePath) => {
+  const result = 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 (!existsSync3(dir) || depth > maxDepth) return [];
+  const results = [];
+  for (const entry of readdirSync(dir)) {
+    const entryPath = resolve2(dir, entry);
+    try {
+      if (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 (!existsSync3(destRoot)) continue;
+    spinner_default.text = `scanning ${cosmetic2.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 ${cosmetic2.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
+import cosmetic3 from "cosmetic";
+import { existsSync as existsSync4, lstatSync as lstatSync2, readdirSync as readdirSync3 } from "fs";
+import { resolve as resolve4 } from "path";
+
+// src/helpers/dirSize.ts
+import { readdirSync as readdirSync2, statSync } from "fs";
+import { resolve as resolve3 } from "path";
+var dirSize = (dir) => {
+  let total = 0;
+  try {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      const full = resolve3(dir, entry.name);
+      if (entry.isDirectory()) {
+        total += dirSize(full);
+      } else if (entry.isFile()) {
+        try {
+          total += 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 readdirSync3(dir).find((f) => {
+      const ext = f.match(/([^.]+$)/)?.[0]?.toLowerCase();
+      return ext && videoExtensions_default.includes(ext);
+    }) ?? null;
+  } catch {
+    return null;
+  }
+};
+var hasSubtitle = (dir) => {
+  try {
+    return readdirSync3(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 (!existsSync4(destRoot)) {
+      console.log(`
+${t.toUpperCase()}  ${cosmetic3.blue.encoder(destRoot)}  (not found)`);
+      continue;
+    }
+    const folders = readdirSync3(destRoot).filter((f) => {
+      try {
+        return lstatSync2(resolve4(destRoot, f)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    const entries = folders.map((folder) => {
+      const folderPath = resolve4(destRoot, folder);
+      const parsed = parseLibraryFolder(folder);
+      const videoFile = findVideoFile(folderPath);
+      const mediaInfo = videoFile ? getMediaInfo(resolve4(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(`
+${cosmetic3.yellow.encoder(t.toUpperCase())}  ${cosmetic3.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 ? cosmetic3.green.encoder("\u2713") : cosmetic3.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
+import chokidar from "chokidar";
+import cosmetic4 from "cosmetic";
+import { cpSync, existsSync as existsSync5, linkSync, lstatSync as lstatSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync4, renameSync, rmSync, statSync as statSync2 } from "fs";
+import { basename, dirname, resolve as resolve5 } from "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
+import { convert } from "roman-numeral";
+import toTitleCase from "to-title-case";
+var titleCase_default = (s) => {
+  s = toTitleCase(s);
+  const ws = s.toLowerCase().split(" ");
+  for (let i = 1; i <= 100; i++) {
+    const roman = 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 (!existsSync5(bExisting)) bExisting = dirname(bExisting);
+    return statSync2(a).dev === statSync2(bExisting).dev;
+  } catch {
+    return false;
+  }
+};
+var moveItem = (src, dest) => {
+  if (sameDev(src, dest)) {
+    renameSync(src, dest);
+  } else {
+    cpSync(src, dest, { recursive: true });
+    rmSync(src, { recursive: true, force: true });
+  }
+};
+var findVideo = (dir) => readdirSync4(dir).find((f) => {
+  const ext = f.match(/([^.]+$)/)?.[0];
+  return ext && videoExtensions_default.includes(ext);
+}) ?? null;
+var findSeasonFolder = (showPath, season) => {
+  if (!existsSync5(showPath)) return null;
+  const folders = readdirSync4(showPath).filter((f) => {
+    try {
+      return lstatSync3(resolve5(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 = basename(entryPath);
+  const movieFormat = config.format?.movie ?? DEFAULT_MOVIE_FORMAT;
+  const seasonFormat = config.format?.season ?? DEFAULT_SEASON_FORMAT;
+  const isDir = lstatSync3(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 = resolve5(destRoot, destName);
+    if (existsSync5(destPath)) {
+      spinner_default.warn(`already exists: ${destName}`);
+      return;
+    }
+    moveItem(entryPath, destPath);
+    recordImport(sessionId, entryPath, destPath, "move");
+    spinner_default.succeed(`imported ${cosmetic4.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 = resolve5(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 = resolve5(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 = resolve5(seasonPath, destVideoName2);
+    const videoSourcePath2 = isDir ? resolve5(entryPath, videoFile2) : entryPath;
+    if (existsSync5(destVideoPath)) {
+      spinner_default.warn(`already exists: ${episodeName}`);
+      return;
+    }
+    const dirFiles2 = isDir ? readdirSync4(entryPath) : [];
+    const subtitle2 = isDir ? findSubtitle(dirFiles2, language) : null;
+    const subtitleExt2 = subtitle2?.match(/([^.]+$)/)?.[0];
+    const subtitleSourcePath2 = subtitle2 ? resolve5(entryPath, subtitle2) : null;
+    const destSubtitleName2 = subtitle2 && subtitleExt2 ? `${episodeName}.${subtitleExt2}` : null;
+    mkdirSync3(seasonPath, { recursive: true });
+    let mode = "move";
+    if (useHardlink) {
+      try {
+        if (!sameDev(videoSourcePath2, seasonPath)) throw new Error("cross-filesystem");
+        linkSync(videoSourcePath2, destVideoPath);
+        mode = "hardlink";
+      } catch {
+        spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${episodeName}`);
+        cpSync(videoSourcePath2, destVideoPath);
+        mode = "copy";
+      }
+      if (subtitleSourcePath2 && destSubtitleName2) cpSync(subtitleSourcePath2, resolve5(seasonPath, destSubtitleName2));
+    } else {
+      if (sameDev(videoSourcePath2, seasonPath)) {
+        renameSync(videoSourcePath2, destVideoPath);
+      } else {
+        cpSync(videoSourcePath2, destVideoPath);
+        rmSync(videoSourcePath2);
+      }
+      if (subtitleSourcePath2 && destSubtitleName2) renameSync(subtitleSourcePath2, resolve5(seasonPath, destSubtitleName2));
+      if (isDir) rmSync(entryPath, { recursive: true, force: true });
+    }
+    recordImport(sessionId, entryPath, seasonPath, mode);
+    spinner_default.succeed(`imported ${cosmetic4.cyan.encoder(`${showFolderName} / ${seasonFolderName} / ${episodeName}`)}`);
+    return;
+  }
+  const edition = detectEdition(entry);
+  const folderName = formatMovieName(movieFormat, parsed.title, parsed.year, edition);
+  const destFolder = resolve5(destRoot, folderName);
+  if (existsSync5(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 ? resolve5(entryPath, videoFile) : entryPath;
+  const dirFiles = isDir ? readdirSync4(entryPath) : [];
+  const subtitle = isDir ? findSubtitle(dirFiles, language) : null;
+  const subtitleExt = subtitle?.match(/([^.]+$)/)?.[0];
+  const subtitleSourcePath = subtitle ? resolve5(entryPath, subtitle) : null;
+  const destSubtitleName = subtitle && subtitleExt ? `${folderName}.${subtitleExt}` : null;
+  if (useHardlink) {
+    mkdirSync3(destFolder, { recursive: true });
+    const destVideoPath = resolve5(destFolder, destVideoName);
+    let mode;
+    try {
+      if (!sameDev(videoSourcePath, destRoot)) throw new Error("cross-filesystem");
+      linkSync(videoSourcePath, destVideoPath);
+      mode = "hardlink";
+    } catch {
+      spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${folderName}`);
+      cpSync(videoSourcePath, destVideoPath);
+      mode = "copy";
+    }
+    if (subtitleSourcePath && destSubtitleName) cpSync(subtitleSourcePath, resolve5(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))) rmSync(resolve5(entryPath, f), { recursive: true, force: true });
+      renameSync(videoSourcePath, resolve5(entryPath, destVideoName));
+      if (subtitleSourcePath && destSubtitleName) renameSync(subtitleSourcePath, resolve5(entryPath, destSubtitleName));
+      moveItem(entryPath, destFolder);
+    } else {
+      mkdirSync3(destFolder, { recursive: true });
+      const destVideoPath = resolve5(destFolder, destVideoName);
+      if (sameDev(videoSourcePath, destRoot)) {
+        renameSync(videoSourcePath, destVideoPath);
+      } else {
+        cpSync(videoSourcePath, destVideoPath);
+        rmSync(videoSourcePath);
+      }
+    }
+    recordImport(sessionId, entryPath, destFolder, "move");
+  }
+  spinner_default.succeed(`imported ${cosmetic4.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 = chokidar.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(`  ${cosmetic4.blue.encoder(s)}`);
+  spinner_default.stop();
+  process.stdin.resume();
+};
+var watch_default = watch;
+
+// src/actions/clean.ts
+import cosmetic5 from "cosmetic";
+import { existsSync as existsSync6, rmSync as rmSync2 } from "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 (!existsSync6(imp.sourcePath)) {
+      if (!dryRun) deleteImport(imp.id);
+      continue;
+    }
+    if (dryRun) {
+      spinner_default.succeed(`[dry] would remove ${cosmetic5.blue.encoder(imp.sourcePath)}`);
+      cleaned++;
+      continue;
+    }
+    try {
+      rmSync2(imp.sourcePath, { recursive: true, force: true });
+      deleteImport(imp.id);
+      spinner_default.succeed(`removed ${cosmetic5.blue.encoder(imp.sourcePath)}`);
+      cleaned++;
+    } catch {
+      spinner_default.warn(`locked or inaccessible, skipped: ${cosmetic5.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
+import cosmetic6 from "cosmetic";
+import { cpSync as cpSync2, existsSync as existsSync7, linkSync as linkSync2, lstatSync as lstatSync4, mkdirSync as mkdirSync4, readdirSync as readdirSync5, renameSync as renameSync2, rmSync as rmSync3, statSync as statSync3 } from "fs";
+import { dirname as dirname2, resolve as resolve6 } from "path";
+import { Select } from "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 (!existsSync7(bExisting)) bExisting = dirname2(bExisting);
+    return statSync3(a).dev === statSync3(bExisting).dev;
+  } catch {
+    return false;
+  }
+};
+var moveFolder = (src, dest) => {
+  if (sameDev2(src, dest)) {
+    renameSync2(src, dest);
+  } else {
+    cpSync2(src, dest, { recursive: true });
+    rmSync3(src, { recursive: true, force: true });
+  }
+};
+var findVideo2 = (dir) => readdirSync5(dir).find((f) => {
+  const ext = f.match(/([^.]+$)/)?.[0];
+  return ext && videoExtensions_default.includes(ext);
+}) ?? null;
+var findSeasonFolder2 = (showPath, season) => {
+  if (!existsSync7(showPath)) return null;
+  const folders = readdirSync5(showPath).filter((f) => {
+    try {
+      return lstatSync4(resolve6(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 (!existsSync7(source)) {
+      spinner_default.warn(`source not found: ${cosmetic6.blue.encoder(source)}`);
+      continue;
+    }
+    spinner_default.text = `scanning ${cosmetic6.blue.encoder(source)}`;
+    for (const entry of readdirSync5(source)) {
+      const entryPath = resolve6(source, entry);
+      const isDir = lstatSync4(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 = resolve6(destRoot, destName);
+        if (existsSync7(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 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 = resolve6(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 = resolve6(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 = resolve6(seasonPath, destVideoName2);
+        const videoSourcePath2 = isDir ? resolve6(entryPath, videoFile2) : entryPath;
+        if (existsSync7(destVideoPath)) {
+          spinner_default.warn(`already exists: ${episodeName}`);
+          skipped++;
+          continue;
+        }
+        const dirFiles2 = isDir ? readdirSync5(entryPath) : [];
+        const subtitle2 = isDir ? findSubtitle(dirFiles2, language) : null;
+        const subtitleExt2 = subtitle2?.match(/([^.]+$)/)?.[0];
+        const subtitleSourcePath2 = subtitle2 ? resolve6(entryPath, subtitle2) : null;
+        const destSubtitleName2 = subtitle2 && subtitleExt2 ? `${episodeName}.${subtitleExt2}` : null;
+        if (!dryRun) {
+          mkdirSync4(seasonPath, { recursive: true });
+          let mode = "move";
+          if (useHardlink) {
+            try {
+              if (!sameDev2(videoSourcePath2, seasonPath)) throw new Error("cross-filesystem");
+              linkSync2(videoSourcePath2, destVideoPath);
+              mode = "hardlink";
+            } catch {
+              spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${episodeName}`);
+              cpSync2(videoSourcePath2, destVideoPath);
+              mode = "copy";
+            }
+            if (subtitleSourcePath2 && destSubtitleName2) cpSync2(subtitleSourcePath2, resolve6(seasonPath, destSubtitleName2));
+          } else {
+            if (sameDev2(videoSourcePath2, seasonPath)) {
+              renameSync2(videoSourcePath2, destVideoPath);
+            } else {
+              cpSync2(videoSourcePath2, destVideoPath);
+              rmSync3(videoSourcePath2);
+            }
+            if (subtitleSourcePath2 && destSubtitleName2) renameSync2(subtitleSourcePath2, resolve6(seasonPath, destSubtitleName2));
+            if (isDir) rmSync3(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 = resolve6(destRoot, folderName);
+      if (existsSync7(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 ? resolve6(entryPath, videoFile) : entryPath;
+      const dirFiles = isDir ? readdirSync5(entryPath) : [];
+      const subtitle = isDir ? findSubtitle(dirFiles, language) : null;
+      const subtitleExt = subtitle?.match(/([^.]+$)/)?.[0];
+      const subtitleSourcePath = subtitle ? resolve6(entryPath, subtitle) : null;
+      const destSubtitleName = subtitle && subtitleExt ? `${folderName}.${subtitleExt}` : null;
+      if (!dryRun) {
+        if (useHardlink) {
+          mkdirSync4(destFolder, { recursive: true });
+          const destVideoPath = resolve6(destFolder, destVideoName);
+          let mode;
+          try {
+            if (!sameDev2(videoSourcePath, destRoot)) throw new Error("cross-filesystem");
+            linkSync2(videoSourcePath, destVideoPath);
+            mode = "hardlink";
+          } catch {
+            spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${folderName}`);
+            cpSync2(videoSourcePath, destVideoPath);
+            mode = "copy";
+          }
+          if (subtitleSourcePath && destSubtitleName) cpSync2(subtitleSourcePath, resolve6(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))) rmSync3(resolve6(entryPath, f), { recursive: true, force: true });
+            renameSync2(videoSourcePath, resolve6(entryPath, destVideoName));
+            if (subtitleSourcePath && destSubtitleName) renameSync2(subtitleSourcePath, resolve6(entryPath, destSubtitleName));
+            moveFolder(entryPath, destFolder);
+          } else {
+            mkdirSync4(destFolder, { recursive: true });
+            const destVideoPath = resolve6(destFolder, destVideoName);
+            if (sameDev2(videoSourcePath, destRoot)) {
+              renameSync2(videoSourcePath, destVideoPath);
+            } else {
+              cpSync2(videoSourcePath, destVideoPath);
+              rmSync3(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
+import cosmetic7 from "cosmetic";
+import { basename as basename2, extname } from "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(`
+${cosmetic7.yellow.encoder(label)}  (${session.records.length} item${session.records.length !== 1 ? "s" : ""})`);
+      for (const r of session.records) {
+        const src = basename2(r.sourcePath);
+        const dest = cosmetic7.cyan.encoder(r.destinationPath);
+        const mode = r.mode !== "move" ? ` ${cosmetic7.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) => extname(r.newPath) === "");
+      console.log(`
+${cosmetic7.yellow.encoder(label)}  (${folders.length} item${folders.length !== 1 ? "s" : ""})`);
+      for (const r of folders) {
+        const oldName = basename2(r.oldPath);
+        const newName = basename2(r.newPath);
+        console.log(`  ${cosmetic7.blue.encoder(oldName)}  \u2192  ${cosmetic7.cyan.encoder(newName)}`);
+      }
+    }
+  }
+  console.log();
+};
+var history_default = history;
+
+// src/actions/undo.ts
+import cosmetic8 from "cosmetic";
+import { renameSync as renameSync3 } from "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) {
+    renameSync3(record.newPath, record.oldPath);
+    spinner_default.succeed(`${cosmetic8.cyan.encoder(record.newPath)} \u2192 ${cosmetic8.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
+import cosmetic9 from "cosmetic";
+import { existsSync as existsSync8, readdirSync as readdirSync6 } from "fs";
+import { resolve as resolve7 } from "path";
+var differences = async ({ dir1: rawDir1, dir2: rawDir2, only, ignore }) => {
+  let dir1 = rawDir1;
+  let dir2 = rawDir2;
+  spinner_default.text = `checking differences between ${cosmetic9.blue.encoder(dir1)} and ${cosmetic9.blue.encoder(dir2)}`;
+  spinner_default.start();
+  dir1 = resolve7(dir1);
+  dir2 = resolve7(dir2);
+  if (!existsSync8(dir1)) throw new Error(`dir1 ${dir1} does not exist`);
+  if (!existsSync8(dir2)) throw new Error(`dir2 ${dir2} does not exist`);
+  let list1 = readdirSync6(dir1);
+  let list2 = readdirSync6(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 ${cosmetic9.blue.encoder(dir1)} and ${cosmetic9.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(`${cosmetic9.green.encoder("added")} ${i}`);
+  for (const i of removed) console.log(`${cosmetic9.red.encoder("removed")} ${i}`);
+};
+var differences_default = differences;
+
+// src/actions/rename.ts
+import cosmetic10 from "cosmetic";
+import { existsSync as existsSync9, lstatSync as lstatSync5, readdirSync as readdirSync7, renameSync as renameSync4 } from "fs";
+import { resolve as resolve8 } from "path";
+import { rimraf } from "rimraf";
+var rename = async ({ dir: inputDir, type, verbose }) => {
+  const dir = resolve8(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 ${cosmetic10.blue.encoder(dir)}`;
+  spinner_default.start();
+  if (!existsSync9(dir)) throw new Error(`dir ${dir} does not exist`);
+  const list2 = readdirSync7(dir);
+  let renamed = 0, removed = 0, skipped = 0;
+  for (const [index, entry] of list2.entries()) {
+    spinner_default.text = `renaming in ${cosmetic10.blue.encoder(dir)} ${index + 1}/${list2.length}`;
+    if (!lstatSync5(resolve8(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 = resolve8(dir, entry);
+      const ps3New = resolve8(dir, `${nameMatch[0]} [${id}]`);
+      renameSync4(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 = readdirSync7(resolve8(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 rimraf(resolve8(dir, entry, f));
+      removed++;
+    }
+    const fileOld = resolve8(dir, entry, video);
+    const fileNew = resolve8(dir, entry, `${formatted}.${ext}`);
+    const folderOld = resolve8(dir, entry);
+    const folderNew = resolve8(dir, formatted);
+    renameSync4(fileOld, fileNew);
+    if (subtitle && subtitleExt) {
+      renameSync4(resolve8(dir, entry, subtitle), resolve8(dir, entry, `${formatted}.${subtitleExt}`));
+    }
+    renameSync4(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 ${cosmetic10.cyan.encoder(dir)}`);
+  spinner_default.stop();
+};
+var rename_default = rename;
+
+// src/actions/reset.ts
+import cosmetic11 from "cosmetic";
+import { existsSync as existsSync10, readdirSync as readdirSync8, renameSync as renameSync5 } from "fs";
+import { basename as basename3, dirname as dirname3, resolve as resolve9, sep } from "path";
+var reset = async ({ dir: inputDir, double }) => {
+  let dir = inputDir;
+  spinner_default.text = `resetting episodes in ${cosmetic11.blue.encoder(dir)}`;
+  spinner_default.start();
+  dir = resolve9(dir);
+  if (!existsSync10(dir)) throw new Error(`dir ${dir} does not exist`);
+  const list2 = readdirSync8(dir).sort();
+  const folder = dir.replace(/\./g, " ").split(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 = basename3(dirname3(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 ${cosmetic11.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;
+    }
+    renameSync5(resolve9(dir, i), resolve9(dir, name));
+    renamed++;
+  }
+  spinner_default.succeed(`renamed ${renamed} files`);
+  spinner_default.info(`skipped ${skipped} files`);
+  spinner_default.succeed(`done in ${cosmetic11.cyan.encoder(dir)}`);
+  spinner_default.stop();
+};
+var reset_default = reset;
+export {
+  DEFAULT_EPISODE_FORMAT,
+  DEFAULT_MOVIE_FORMAT,
+  DEFAULT_SEASON_FORMAT,
+  clean_default as clean,
+  configAdd,
+  configRemove,
+  configSet,
+  configShow,
+  deleteImport,
+  deleteSession,
+  detectEdition,
+  differences_default as differences,
+  formatEpisode,
+  formatMovieName,
+  formatSeasonFolder,
+  getCleanableImports,
+  getConfig,
+  getHistory,
+  getImportByDest,
+  getLastSession,
+  getMediaInfo,
+  history_default as history,
+  list_default as list,
+  normalizeCodec,
+  normalizeResolution,
+  parseDownloadName,
+  parseQuality,
+  probe_default as probe,
+  recordImport,
+  recordRename,
+  rename_default as rename,
+  reset_default as reset,
+  saveConfig,
+  scan_default as scan,
+  titleCase_default as titleCase,
+  undo_default as undo,
+  upsertMediaInfo,
+  videoExtensions_default as videoExtensions,
+  watch_default as watch
+};