285 lines
19 KiB
Markdown
285 lines
19 KiB
Markdown
# Aurora Curator
|
|
|
|
A fast, cross-platform media renamer — a ground-up rewrite of FileBot (via its FB-Mod
|
|
fork), built from scratch as its own project: new stack, new architecture, new branding.
|
|
|
|
**Status: early scaffold, but the core loop works end to end.** The naming-expression
|
|
engine is ported and tested, the faithfully-recreated two-pane UI is wired to real
|
|
native file/folder loading and drag-and-drop, local filename-based season/episode *and
|
|
movie title/year* detection ("Match") is working, real online metadata lookups against
|
|
TMDB ("Fetch Data") are working for both TV episodes and movies — including fuzzy
|
|
title disambiguation, so a search that returns several similarly-named results doesn't
|
|
just take TMDB's top-ranked hit — and the actual on-disk operation is wired up (with a
|
|
confirmation step showing the full old-path/new-path plan before anything touches disk,
|
|
a per-row ✕ to drop an individual file from that plan at the last step, a Move/Copy/
|
|
Symlink selector for what to actually do at each target, and — independently — a Skip/
|
|
Auto-number/Override selector for what happens when the computed name already exists:
|
|
leave it alone (the original, and still default, behavior), save alongside it as
|
|
"Name (1).ext", or replace it outright). It can also organize files into subfolders —
|
|
including ones that don't exist yet — when the naming scheme includes a `/`. Every
|
|
completed batch is logged to a history panel that can undo it (moving files back for
|
|
Move, or just removing what was created for Copy/Symlink — undoing always uses its own
|
|
skip-on-conflict policy regardless of what the original rename used, so an undo can
|
|
never overwrite something else as a side effect). A single loaded batch can freely mix
|
|
TV episodes and movies
|
|
— each file only fills in the fields that apply to it. "Match" also parses release-tag
|
|
text straight out of the filename — resolution, source (BluRay/HDTV/WEB-DL/…),
|
|
video/audio codec, release group — so naming schemes can reference
|
|
`{resolution}`/`{source}`/`{video codec}`/`{audio codec}`/`{release group}` (or
|
|
FileBot's own `{vf}`/`{source}`/`{vc}`/`{ac}`/`{group}`) without a media prober; the
|
|
rest of FileBot's full media-metadata bindings (real probed video/audio stream info)
|
|
are not yet ported. The Align Up/Down buttons reorder the (shared) file list — the two
|
|
panes always stay positionally paired — and up to 9 naming schemes can be saved as
|
|
presets, recalled with a click or a `1`-`9` keypress (persisted locally, same pattern as
|
|
Settings/History). See "Porting roadmap" below.
|
|
|
|
The naming scheme is fully user-editable from the app (the "Naming Scheme" button next
|
|
to the New Names list) — the default is `{show name} - {season number}x{episode
|
|
number} - {episode name}`, but it's just a starting point, not a fixed template.
|
|
Plain, human-readable, multi-word field names like `{show name}` work directly (no
|
|
Rhai knowledge needed), FileBot's own short field names (`{n}`, `{s00e00}`, `{t}`)
|
|
still work side by side with them, and real Rhai script is available for anyone who
|
|
wants it (e.g. `{show name.to_upper()}`). See "Naming scheme syntax" below for how
|
|
that's implemented.
|
|
|
|
## Why a rewrite, and why this stack
|
|
|
|
The original is a ~20k+ line Java/Swing app built with Ant. The goals were: faster
|
|
startup and UI, faster matching/renaming, a codebase that's actually pleasant to work
|
|
in, and a genuine rebrand — not a coat of paint.
|
|
|
|
Aurora Curator is **Tauri**: a Rust core (`crates/aurora-curator-core`, `src-tauri`) plus a
|
|
TypeScript/React frontend (`src`), compiled to a small native binary per platform
|
|
(Windows/macOS/Linux) with a system webview instead of shipping a bundled browser
|
|
engine. That's the concrete "faster" win over both the original JVM/Swing app and
|
|
an Electron-style rewrite: quick cold start, small binary, real OS-native windowing.
|
|
|
|
An earlier attempt used Kotlin + Compose Multiplatform to stay on the JVM and reuse
|
|
FileBot's Java logic directly. That was abandoned (nothing was salvaged into this repo)
|
|
after discovering the sandbox this was originally built in blocks Maven Central and the
|
|
Gradle Plugin Portal, making it impossible to compile or test. Tauri was chosen as the
|
|
replacement because both halves — Cargo via crates.io, npm via the public npm registry
|
|
— are reachable, so every piece described as "done" below is actually compiled/tested,
|
|
not just written and hoped for.
|
|
|
|
### Compatibility notes
|
|
|
|
Goal: keep CLI flags, config file locations, and the *outer* `{ }` naming-scheme
|
|
template syntax compatible with FileBot conventions, so existing automation mostly
|
|
keeps working.
|
|
|
|
One deliberate gap: FileBot's `{ }` expressions ran arbitrary **Groovy** code
|
|
(JVM-only). Aurora Curator's Rust core has no Groovy engine, so expressions are evaluated with
|
|
[Rhai](https://rhai.rs/) instead. Simple bindings (`{n}`, `{s00e00}`, `{t}`) are
|
|
identical. More complex chained-method expressions will need small syntax tweaks
|
|
(e.g. Groovy's `.toUpperCase()` → Rhai's `.to_upper()`) — Rhai already ships most of the
|
|
common string/array methods FileBot's expression helpers wrapped, so most patterns
|
|
translate directly.
|
|
|
|
### Naming scheme syntax
|
|
|
|
Every `{ }` token in an expression is resolved in this order
|
|
(`crates/aurora-curator-core/src/format/expression.rs::compile_scriptlet`):
|
|
|
|
1. **A single bare identifier** (`{n}`, `{season}`) is a direct binding lookup — the
|
|
fast path, and how FileBot's own short field names keep working unmodified.
|
|
2. Otherwise it's **compiled as Rhai script** (`{n.to_upper()}`, `{n + " " + t}`) —
|
|
real code, with every current binding available as a script variable.
|
|
3. If it's *neither* a valid identifier *nor* valid Rhai, but it still only contains
|
|
letters, digits, underscores and spaces (e.g. `{show name}`, `{episode number}`),
|
|
it falls back to a **literal multi-word binding key** instead of raising a syntax
|
|
error — this is what lets a human-typed field name with spaces work as a plain
|
|
lookup without anyone needing to know Rhai. Anything that isn't a plausible field
|
|
name (stray punctuation, unmatched brackets, etc.) still surfaces as a real syntax
|
|
error at that point, exactly as before.
|
|
|
|
An undefined binding contributes an empty string rather than failing outright (so
|
|
`{n}{missing}` still renders); the overall expression only errors if the *total*
|
|
rendered output would be empty.
|
|
|
|
`/` between two `{ }` scriptlets (or anywhere in the literal text) needs no special
|
|
handling in the expression engine at all — it's just ordinary literal text, the same as
|
|
a space or a dash. It only becomes meaningful one layer up, at rename time (see
|
|
"Organizing into subfolders" below): a scheme like `{show name}/{episode name}` renders
|
|
to a name containing a real `/`, and the rename engine treats that as "put this file in
|
|
a subfolder" rather than rejecting it.
|
|
|
|
### Organizing into subfolders
|
|
|
|
A naming scheme that includes `/` (e.g. `{show name}/Season {season number}/{episode
|
|
number} - {episode name}`) moves the file into that subfolder as part of renaming,
|
|
creating any missing intermediate folders automatically
|
|
(`crates/aurora-curator-core/src/rename/mod.rs::rename_one` → `fs::create_dir_all`). This is
|
|
still always scoped to the file's own directory tree — the target is resolved relative
|
|
to the source file's parent directory, never as an absolute path, and every path
|
|
component is validated (`validate_relative_target`) to reject empty segments (a
|
|
leading, trailing, or doubled `/` — which also catches an absolute-looking
|
|
`/etc/passwd`-style path), `.`/`..` segments, and backslashes (Aurora Curator always uses `/`
|
|
for the naming scheme's folder separator regardless of OS). If the resolved target
|
|
already exists and isn't the same underlying file, what happens next is up to the
|
|
chosen conflict policy — Skip (default), Auto-number, or Override; see item 6 of the
|
|
porting roadmap below for the full behavior of each.
|
|
|
|
## Project layout
|
|
|
|
```
|
|
crates/aurora-curator-core/ Pure Rust core: naming-expression engine (ported), local
|
|
filename-based season/episode *and movie title/year* matching
|
|
(ported, `matching/`), plus filename-based release-tag parsing in
|
|
the same module (`guess_release_info` — resolution, source, video/
|
|
audio codec, release group), text-similarity scoring for
|
|
disambiguating search results (`similarity/`, partial
|
|
`EpisodeMetrics` port), a TMDB metadata client (`web/tmdb.rs` — TV
|
|
search + episode lookup
|
|
and movie search + lookup, both disambiguated via `similarity/`,
|
|
tested against a mocked HTTP server via `mockito`), the on-disk
|
|
rename engine (`rename/` — Move/Copy/Symlink actions,
|
|
Skip/Auto-number/Override conflict policies, can also organize
|
|
into (auto-created) subfolders when
|
|
the naming scheme includes `/`) — and a rename history/undo log
|
|
(`history/`, a partial `HistoryDialog` port, undo-aware of which
|
|
action produced each batch). Not yet ported: full media metadata
|
|
bindings, other web datasource clients (TVDB/AniDB/etc).
|
|
No Tauri dependency, so it builds and unit-tests standalone.
|
|
src-tauri/ Tauri app shell: exposes aurora-curator-core as commands to the frontend
|
|
(naming-scheme rendering, filename matching for both TV and
|
|
movies, TMDB metadata fetch — `metadata.rs` for TV episodes,
|
|
plus a movie-fetch command alongside it — executing a rename
|
|
plan, native file/folder dialogs, drag-and-drop expansion), plus
|
|
`settings.rs` (TMDB token), `history.rs` (rename history/undo
|
|
log), and `presets.rs` (up to 9 saved naming schemes) — all three
|
|
stored as JSON in the OS app-config directory — app
|
|
metadata/icons/window config (tauri.conf.json).
|
|
src/ React + TypeScript UI (Vite). Faithful recreation of the original
|
|
two-pane rename screen (Aurora theme) wired to real file loading,
|
|
drag-and-drop, live naming-scheme preview, local TV/movie
|
|
matching, TMDB fetch for both (behind a Settings modal for the
|
|
API token), a confirm-before-touching-disk modal for the actual
|
|
rename, a History panel that can undo a past rename, Align Up/Down
|
|
list reordering, and a Presets panel (plus `1`-`9` hotkeys) for
|
|
saved naming schemes.
|
|
scripts/gen_icons.py Regenerates src-tauri/icons/ (placeholder branding — swap the
|
|
colors/glyph in the script, or replace the icons directly, to
|
|
change the look).
|
|
```
|
|
|
|
## Building
|
|
|
|
Prerequisites: Rust (stable) + Cargo, Node.js 18+, and Tauri's platform prerequisites
|
|
(see https://v2.tauri.app/start/prerequisites/ — on Linux this means
|
|
`libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev` and a C
|
|
toolchain; macOS/Windows need Xcode / the VS Build Tools + WebView2 respectively).
|
|
|
|
```sh
|
|
# Rust core (no UI deps needed):
|
|
cargo test -p aurora-curator-core
|
|
|
|
# Full app in dev mode (opens a native window):
|
|
npm install
|
|
npm run tauri dev
|
|
|
|
# Production build (installer/bundle for your current OS):
|
|
npm run tauri build
|
|
```
|
|
|
|
Verified in the environment this was built in: `cargo test -p aurora-curator-core` (all
|
|
passing, including the TMDB client tests — those run against a local mock HTTP server
|
|
via `mockito`, no live network or API key needed to build/test), `cargo check -p
|
|
aurora-curator` (compiles clean against real Tauri + GTK/WebKit system libraries), and `npm run
|
|
build` (TypeScript type-checks, Vite bundles). The actual GUI window has **not** been
|
|
visually verified anywhere yet — that sandbox has no display. Run `npm run tauri dev`
|
|
on your machine to see and click through it for the first time.
|
|
|
|
### Setting up TMDB (for "Fetch Data")
|
|
|
|
Everything else in the app works fully offline; "Fetch Data" is the one feature that
|
|
needs a (free) [TMDB](https://www.themoviedb.org/) account:
|
|
|
|
1. Create a TMDB account, then go to Settings → API in your account and generate an
|
|
**API Read Access Token** (not the older numeric "API Key" — Aurora Curator uses the Bearer
|
|
token method TMDB documents as the default).
|
|
2. In the app, click the key icon ("TMDB Settings") next to Fetch Data and paste the
|
|
token in. It's saved locally in the OS app-config directory and only ever sent to
|
|
`api.themoviedb.org`.
|
|
|
|
## Porting roadmap (not yet done)
|
|
|
|
Roughly in priority order — each references the original FileBot source file it's
|
|
ported from, for anyone picking this up:
|
|
|
|
1. **Full naming-scheme bindings** — `net.filebot.format.MediaBindingBean` (1354 lines):
|
|
all the `{n}`, `{s00e00}`, `{airdate}`, `{vf}` (video format), etc. binding
|
|
properties. A filename-tag-based subset is now ported and wired to "Match"
|
|
(`guess_release_info` in `crates/aurora-curator-core/src/matching`): `{vf}`/`{resolution}`,
|
|
`{source}`, `{vc}`/`{video codec}`, `{ac}`/`{audio codec}`, `{group}`/`{release
|
|
group}`. What's still missing is everything MediaBindingBean derives from actually
|
|
*probing* the media file (real video/audio stream resolution, duration, bitrate,
|
|
frame rate, file size/hash, etc.) — Aurora Curator ships no ffprobe/MediaInfo dependency, so
|
|
those bindings only work when a release name happens to carry the info as text.
|
|
2. **String/expression helper methods** — `net.filebot.format.ExpressionFormatMethods`
|
|
(636 lines): FileBot-specific Groovy string extensions like `.pad()`, `.sortName()`.
|
|
Only a small subset (`any`, `all_of`, `concat`) is ported so far
|
|
(`crates/aurora-curator-core/src/format/functions.rs`); Rhai's built-ins cover some of the
|
|
rest already.
|
|
3. **Matching/similarity engine** — `net.filebot.similarity.*`. Local filename-based
|
|
season/episode detection is done (`crates/aurora-curator-core/src/matching`, ported from the
|
|
pattern-matching half of `SeasonEpisodeMatcher.java`, adapted to Rust's `regex` crate
|
|
which lacks lookahead/lookbehind — wired to the "Match" button), and so is a local
|
|
movie title/year heuristic (`guess_movie` in the same module) used as a fallback
|
|
whenever a filename carries no season/episode marker — a release name is either a TV
|
|
episode or a movie, never both. Title disambiguation is also done
|
|
(`crates/aurora-curator-core/src/similarity`, a partial port of the *scoring* idea behind
|
|
`EpisodeMetrics.java`'s fuzzy title-matching cascade — Sorensen-Dice similarity over
|
|
normalized-title character bigrams), shared by both the TV and movie TMDB lookups:
|
|
"Fetch Data" picks whichever TMDB search result is textually closest to the local
|
|
guess rather than just trusting TMDB's relevance/popularity-ranked first hit, and
|
|
reports "not found" instead of guessing when nothing in the results is a plausible
|
|
match at all. `DateMatcher` (numbering/air-date-based identification, the other half
|
|
of the original `EpisodeMetrics`) is not ported — Aurora Curator doesn't do date-based
|
|
episode identification.
|
|
4. **Media detection** — `net.filebot.media.MediaDetection` (1356 lines): ties file-name
|
|
parsing + matching together to auto-identify what a file is.
|
|
5. **Web datasource clients** — `net.filebot.web.*` (~40 files): TheMovieDB, TheTVDB,
|
|
AniDB, OMDb, TVmaze, OpenSubtitles, etc. TMDB is done for both TV and movies
|
|
(`crates/aurora-curator-core/src/web/tmdb.rs`, `reqwest` + `serde_json`, Bearer-token auth) —
|
|
search-by-name plus per-season episode lookup for TV, search-by-title (optionally
|
|
narrowed by release year via TMDB's own `primary_release_year` filter) for movies —
|
|
both wired to "Fetch Data", disambiguating multi-result searches via the
|
|
similarity-scoring pass described in item 3 above rather than blindly trusting
|
|
TMDB's top-ranked hit. All other sources (TheTVDB, AniDB, OMDb, TVmaze,
|
|
OpenSubtitles) are not yet started.
|
|
6. **Rename engine + CLI** — `net.filebot.cli.CmdlineOperations` (1235 lines) and
|
|
`ArgumentBean` (415 lines, the full flag surface: `-rename`, `--db`, `--format`,
|
|
`--action`, `--conflict`, `-get-subtitles`, `-script`, etc.). The rename operation is
|
|
done (`crates/aurora-curator-core/src/rename`, wired to the UI's Rename button behind a
|
|
confirmation step) including the `move`-into-subfolder `--action` variant — a naming
|
|
scheme like `{n}/{s00e00}` organizes files into subfolders, creating any missing
|
|
folders automatically, always scoped to the file's own directory tree. The
|
|
`copy`/`symlink` `--action` variants are done too — an action selector in the
|
|
confirmation modal picks Move/Copy/Symlink for the whole batch; Copy and Symlink both
|
|
leave the source file untouched and produce a new file/link at the computed target,
|
|
and both are undoable from the History panel the same as Move (undo for Copy/Symlink
|
|
just removes what was created, since there's nothing to move back). The `--conflict`
|
|
variants are done too — a second selector in the same modal picks Skip (default,
|
|
leaves the conflicting file alone), Auto-number (`"Name (1).ext"`, counting up to the
|
|
first free slot), or Override (replaces the conflicting file outright — the one
|
|
irreversible option, called out with red styling in the UI; undoing that batch later
|
|
restores the *source*, never what got overwritten, since undo always uses its own
|
|
fixed skip-on-conflict policy no matter which policy the original rename used). Not
|
|
yet done: the CLI flag surface itself.
|
|
7. **The rest of the UI** — the Rename panel (file loading, drag-drop, live preview,
|
|
local TV/movie matching, confirmed rename with per-item exclude, rename history/undo,
|
|
Align Up/Down reordering, naming-scheme Presets with `1`-`9` hotkeys) is built; the
|
|
other five sidebar panels (Episodes/Subtitles/SFV/Filter/List) are still stub
|
|
screens. Align Up/Down is button-based (swaps the selected file with its neighbor),
|
|
not the original's drag-and-drop-within-a-list interaction.
|
|
8. **Undo/history for renames** — done, as a flat JSON-backed undo stack rather than a
|
|
full port of `net.filebot.HistoryDialog`'s session/element log
|
|
(`crates/aurora-curator-core/src/history`, `src-tauri/src/history.rs`). Every successful
|
|
rename is recorded to a `history.json` in the OS app-config directory (same location
|
|
as `settings.json`); the History panel lists past batches and can revert one back to
|
|
its original paths, skipping (never overwriting) any file whose original path now
|
|
has something else at it. Capped at the 50 most recent batches.
|
|
9. **Packaging** — code signing, auto-update, installers per platform via
|
|
`npm run tauri build`.
|