riplex 0.7.2__tar.gz → 0.7.4__tar.gz

{riplex-0.7.2/src/riplex.egg-info → riplex-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.7.2
+Version: 0.7.4
 Summary: Automates the tedious manual work around MakeMKV: figuring out what to rip, which MKV files are actually what, and organizing everything into Plex-compatible folder structures.
 License: MIT
 Requires-Python: >=3.11

{riplex-0.7.2 → riplex-0.7.4}/docs/changelog.md

@@ -4,6 +4,18 @@ All notable changes to the riplex documentation are recorded here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## v0.7.4 — 2026-06-10
+
+### Fixed
+
+- **GUI: empty Disc Overview after continuing without dvdcompare data.** When dvdcompare had no matching release, the orchestrate flow still navigated to the multi-disc overview, which only renders dvdcompare-provided disc rows. The no-dvdcompare fallback now treats the inserted disc as a single-disc rip and jumps directly to title selection, where TMDb runtime heuristics can pick the main feature.
+
+## v0.7.3 — 2026-06-10
+
+### Fixed
+
+- **GUI: silent "No optical drives detected" when MakeMKV is expired or unregistered.** When `makemkvcon` rejects requests with a fatal MSG (codes `5021` too-old, `5022` key-expired, `5023` key-invalid) it exits cleanly with zero `DRV:` lines, so riplex previously rendered an empty drive list. The shared library now parses these fatal MSGs and raises `MakeMKVError`; the Disc Detection screen surfaces the verbatim `makemkvcon` message along with **Download MakeMKV ↗** and **Get beta key ↗** buttons so users can resolve the lockout in one click.
+
 ## v0.7.2 — 2026-05-17
 
 ### Fixed

riplex-0.7.4/issues/manual-rip-and-organize-escape-hatch.md

@@ -0,0 +1,106 @@
+# GUI: manual rip and manual organize escape hatches
+
+## Problem
+
+When riplex can't classify a disc — no dvdcompare match, ambiguous TMDb
+result, multi-feature compilation, region-coded oddity, etc. — the GUI flow
+dead-ends at the title-selection screen. The user has to leave riplex-ui,
+launch the MakeMKV GUI to rip the disc directly, and then either keep those
+files unorganized or manually rename and move them into Plex layout.
+
+We hit this in practice with a BBC Earth Blu-ray containing two unrelated
+features (*Wild Africa* + *Tiny Giants*). The disc isn't on dvdcompare, TMDb
+has only a combined "double feature" entry, and riplex's planner assumes one
+disc → one TMDb item, so the rip flow couldn't proceed at all.
+
+## Why we don't want to model compilations directly
+
+Compilation discs that contain multiple unrelated films are rare enough that
+building first-class support (per-title TMDb matching, per-title disc
+metadata, multi-target organize) isn't justified. A generic escape hatch is
+cheaper and covers other niche scenarios as a side benefit (foreign releases
+without metadata, damaged-disc recovery, special workshop discs, etc.).
+
+## Proposed UX
+
+Two new entry points in the GUI, both intentionally generic:
+
+### 1. "Manual rip" button on the title-selection screen
+
+When riplex can't classify titles confidently (no dvdcompare match **and**
+TMDb selection is ambiguous, or user just wants raw control), surface a
+"Manual rip" button alongside the existing "Rip selected" button.
+
+Clicking it drops the user into a flat MakeMKV-style title list:
+
+- All titles, sorted by index, with duration / size / chapter count
+- Checkbox per title (default: all titles longer than 2 minutes)
+- Output folder picker (defaults to `<output_root>/_MakeMKV/<disc_label>/`)
+- "Rip" button → calls `makemkvcon mkv all` (or per-title) and shows the
+  existing progress UI
+
+No metadata lookup, no organize, no Plex naming. The user lands in the "Done"
+screen with a folder of raw MKVs, with a follow-up button: "Organize this
+folder now → opens the manual organize screen pre-pointed at that path."
+
+### 2. "Organize existing folder" entry on the welcome screen
+
+A second card on welcome (next to "Rip a disc") titled "Organize existing
+files." Picks up an arbitrary folder of MKVs and walks the user through:
+
+1. **Folder picker** → list MKVs with sizes and ffprobe runtimes.
+2. **TMDb search** (reuses existing `metadata` screen) → select the canonical
+   entry.
+3. **File assignment** → for each MKV, drop-down: `Main feature`, `Part 1
+   (-pt1)`, `Part 2 (-pt2)`, `Extra → behindthescenes`, `Extra → featurette`,
+   `Extra → trailer`, `Skip`. Auto-suggest based on duration.
+4. **Plan preview** → show source → destination paths.
+5. **Apply** → move + rename into Plex layout, with the existing dry-run
+   default and `Execute` toggle.
+
+This is essentially the existing `riplex organize` CLI behavior with a GUI in
+front of it. No new business logic — just a thin wrapper that also handles
+the "two parts of one TMDb movie" case via the assignment step.
+
+## Why this works for the BBC Earth case
+
+End-to-end flow stays inside riplex-ui:
+
+1. Insert disc → riplex tries to classify, fails to find dvdcompare match.
+2. User clicks **Manual rip**, picks the two main titles, hits Rip.
+3. Done screen → click **Organize this folder**.
+4. TMDb search → "Wild Africa Tiny Giants" → pick `tmdb-1657586`.
+5. Assign t00 → pt1, t01 → pt2.
+6. Apply → files land in `Movies\Wild Africa - Tiny Giants (2016)\`.
+
+No external tool, no manual `Move-Item`.
+
+## Tradeoffs
+
+- **Pro**: covers any disc riplex can't classify, not just compilations.
+- **Pro**: reuses existing rip + organize plumbing; mostly UI work.
+- **Con**: more GUI surface (two screens, file-assignment widget).
+- **Con**: risk of users defaulting to manual mode and bypassing the smart
+  classification we built. Mitigation: gate the manual-rip button behind a
+  "we couldn't classify this disc" trigger or an "Advanced" reveal, so it's
+  not a peer to the normal "Rip selected" button on every disc.
+
+## Out of scope
+
+- Per-title TMDb matching (full compilation support).
+- Multi-target organize where one folder of MKVs maps to N different TMDb
+  entries. Manual mode handles this by running the organize wizard once per
+  target with file selection.
+- Saving manual-mode decisions for repeat use (cache).
+
+## Files likely involved
+
+- `src/riplex_app/screens/selection.py` — add "Manual rip" button + branch.
+- `src/riplex_app/screens/manual_rip.py` (new) — flat title list + ripper.
+- `src/riplex_app/screens/welcome.py` — add "Organize existing files" card.
+- `src/riplex_app/screens/manual_organize.py` (new) — folder picker → TMDb →
+  assignment → plan preview → apply.
+- `src/riplex/organizer.py` — already has the path-building logic; may need
+  a small helper for the assignment data structure.
+- `src/riplex_cli/commands/organize.py` — sanity-check the CLI still works
+  after any planner refactor.

{riplex-0.7.2 → riplex-0.7.4}/src/riplex/detect.py

@@ -10,7 +10,9 @@ import logging
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
+
+from riplex.title import parse_season_number, parse_title_and_season, strip_year_from_title
 
 if TYPE_CHECKING:
     from riplex.models import ScannedDisc, ScannedFile
@@ -34,9 +36,18 @@ class TitleGroup:
 
     title: str
     folders: list[Path] = field(default_factory=list)
+    season_number: int | None = None
     detected_format: str | None = None
 
 
+@dataclass
+class OrganizeLayout:
+    """How an organize root should be processed."""
+
+    mode: Literal["single", "batch", "empty"]
+    groups: list[TitleGroup] = field(default_factory=list)
+
+
 def detect_format(discs: list[ScannedDisc]) -> str | None:
     """Infer disc format from the maximum video resolution across all files.
 
@@ -124,7 +135,8 @@ def group_title_folders(root: Path) -> list[TitleGroup]:
     Ignores folders starting with ``_`` (e.g. ``_archive``).
     Returns groups sorted by title, each containing the original folder paths.
     """
-    groups: dict[str, list[Path]] = {}
+    groups: dict[tuple[str, int | None], list[Path]] = {}
+    root_title, _ = strip_year_from_title(root.name)
 
     for sub in sorted(root.iterdir()):
         if not sub.is_dir():
@@ -142,14 +154,38 @@ def group_title_folders(root: Path) -> list[TitleGroup]:
             continue
 
         base = _normalize_title(sub.name)
-        groups.setdefault(base, []).append(sub)
+        title, season_number = parse_title_and_season(base)
+        if title is None and season_number is not None:
+            title = root_title
+        if title is None:
+            title = base
+            season_number = parse_season_number(base)
+        groups.setdefault((title, season_number), []).append(sub)
 
     result: list[TitleGroup] = []
-    for title in sorted(groups):
-        result.append(TitleGroup(title=title, folders=groups[title]))
+    for title, season_number in sorted(groups):
+        result.append(TitleGroup(title=title, folders=groups[(title, season_number)], season_number=season_number))
     return result
 
 
+def detect_organize_layout(root: Path) -> OrganizeLayout:
+    """Classify an organize root as single-title, batch, or empty.
+
+    Single mode covers a flat folder of MKVs or a folder whose immediate
+    subfolders are disc folders. Batch mode covers roots that contain nested
+    season/title folders such as ``Show/Season 6/Disc 1``.
+    """
+    has_root_mkvs = any(root.glob("*.mkv"))
+    has_sub_mkvs = any(root.glob("*/*.mkv"))
+    has_nested_mkvs = any(root.glob("*/*/*.mkv"))
+
+    if has_root_mkvs or (has_sub_mkvs and not has_nested_mkvs):
+        return OrganizeLayout(mode="single")
+    if has_sub_mkvs or has_nested_mkvs:
+        return OrganizeLayout(mode="batch", groups=group_title_folders(root))
+    return OrganizeLayout(mode="empty")
+
+
 def infer_media_type(disc_info) -> str:
     """Infer 'movie' or 'tv' from disc title structure.
 

{riplex-0.7.2 → riplex-0.7.4}/src/riplex/disc/makemkv.py

@@ -114,6 +114,15 @@ class MakeMKVPreflight:
     error: str = ""  # short human-readable failure reason
 
 
+class MakeMKVError(RuntimeError):
+    """makemkvcon ran but refused to do useful work (e.g. expired beta key)."""
+
+    def __init__(self, message: str, *, code: int | None = None, raw: str = ""):
+        super().__init__(message)
+        self.code = code
+        self.raw = raw
+
+
 @dataclass
 class DiscInfo:
     """Parsed disc information from makemkvcon -r info."""
@@ -276,6 +285,43 @@ def parse_drive_list(output: str) -> list[DriveInfo]:
     return drives
 
 
+# MSG codes makemkvcon emits when it refuses to do real work. The user-facing
+# message is the first quoted field. Anything in this set should be surfaced
+# verbatim to the user with an actionable hint, since the rest of the run
+# will silently produce empty results otherwise (no DRV lines, no titles).
+_MAKEMKV_FATAL_MSG_CODES: frozenset[int] = frozenset({
+    5021,  # "This application version is too old..." (expired beta key)
+    5022,  # registration key expired
+    5023,  # registration key invalid
+})
+
+
+def parse_fatal_message(output: str) -> tuple[int, str] | None:
+    """Return ``(code, message)`` for the first known fatal MSG line, else None.
+
+    makemkvcon emits ``MSG:<code>,<flags>,<count>,"<text>",...`` lines.
+    When it refuses to scan (expired beta, invalid key, etc.) it prints
+    one of those and then exits without any ``DRV:`` lines, which makes
+    ``parse_drive_list`` legitimately return ``[]``. Callers can use
+    this helper to distinguish "no drives" from "makemkvcon won't run".
+    """
+    for line in output.splitlines():
+        if not line.startswith("MSG:"):
+            continue
+        parts = _split_robot_line(line[4:])
+        if len(parts) < 4:
+            continue
+        try:
+            code = int(parts[0])
+        except ValueError:
+            continue
+        if code not in _MAKEMKV_FATAL_MSG_CODES:
+            continue
+        # parts[3] is the rendered, human-readable message text.
+        return code, parts[3]
+    return None
+
+
 def _split_robot_line(text: str) -> list[str]:
     """Split a makemkvcon robot-mode CSV line, respecting quoted strings."""
     parts: list[str] = []
@@ -415,7 +461,12 @@ class MakeMKV:
         return parse_disc_info(output)
 
     def drive_list(self) -> list[DriveInfo]:
-        """List available optical drives."""
+        """List available optical drives.
+
+        Raises :class:`MakeMKVError` if makemkvcon ran but returned no
+        drive lines because of a known fatal condition (most commonly
+        an expired beta version that refuses to scan until updated).
+        """
         exe = self._require_exe()
 
         cmd = [str(exe), "-r", "info", "list"]
@@ -429,7 +480,13 @@ class MakeMKV:
             **_SUBPROCESS_FLAGS,
         )
         output = result.stdout + result.stderr
-        return parse_drive_list(output)
+        drives = parse_drive_list(output)
+        if not drives:
+            fatal = parse_fatal_message(output)
+            if fatal is not None:
+                code, message = fatal
+                raise MakeMKVError(message, code=code, raw=output)
+        return drives
 
     def resolve_drive(self, drive_arg: str = "auto") -> DriveInfo:
         """Resolve a drive argument to a :class:`DriveInfo`.

{riplex-0.7.2 → riplex-0.7.4}/src/riplex/lookup.py

@@ -63,8 +63,11 @@ async def lookup_metadata(
 
     if not skip_dvdcompare:
         try:
+            dvdcompare_title = canonical
+            if not is_movie and request.season_number is not None:
+                dvdcompare_title = f"{canonical}: Season {request.season_number}"
             discs, release_name = await fetch_and_select_release(
-                canonical,
+                dvdcompare_title,
                 disc_format=disc_format,
                 disc_info=disc_info,
                 preferred=preferred_release,

{riplex-0.7.2 → riplex-0.7.4}/src/riplex/metadata/planner.py

@@ -139,6 +139,8 @@ async def _plan_show(
 
     seasons: list[PlannedSeason] = []
     for sm in detail.seasons:
+        if request.season_number is not None and sm.season_number != request.season_number:
+            continue
         episodes: list[PlannedEpisode] = []
         for em in sm.episodes:
             fname = episode_file_name(

{riplex-0.7.2 → riplex-0.7.4}/src/riplex/models.py

@@ -12,6 +12,7 @@ class SearchRequest:
 
     title: str
     year: int | None = None
+    season_number: int | None = None
     media_type: Literal["movie", "tv", "auto"] = "auto"
     include_specials: bool = True
     include_extras_skeleton: bool = True

{riplex-0.7.2 → riplex-0.7.4}/src/riplex/title.py

@@ -15,6 +15,14 @@ _TRAILING_SEASON_DISC_RE = re.compile(
     r"\s*[-_]?\s*S(?:eason|t)?\s*\d+[\s_-]*(?:BD|B(?:lu[-_ ]*ray)|D(?:isc)?)[\s_-]*\d+\s*$",
     re.IGNORECASE,
 )
+_SEASON_NUMBER_RE = re.compile(
+    r"(?:^|[\s_-])(?:Season|S|St)\s*0*(\d{1,2})(?=$|[\s_-])",
+    re.IGNORECASE,
+)
+_SEASON_TOKEN_RE = re.compile(
+    r"(?:^|[\s_-])(?:Season|S|St)\s*0*(\d{1,2})(?=$|[\s_-])",
+    re.IGNORECASE,
+)
 
 
 def strip_year_from_title(name: str) -> tuple[str, int | None]:
@@ -81,3 +89,28 @@ def parse_volume_label(label: str) -> str | None:
         else:
             result.append(w.capitalize())
     return " ".join(result)
+
+
+def parse_season_number(label: str) -> int | None:
+    """Extract a season number from a folder or label string."""
+    if not label:
+        return None
+    match = _SEASON_NUMBER_RE.search(label)
+    if not match:
+        return None
+    try:
+        return int(match.group(1))
+    except ValueError:
+        return None
+
+
+def parse_title_and_season(label: str) -> tuple[str | None, int | None]:
+    """Extract a base title and optional season number from a label string."""
+    if not label or len(label) < 2:
+        return None, None
+
+    season_number = parse_season_number(label)
+    cleaned = _TRAILING_SEASON_DISC_RE.sub("", label)
+    cleaned = _SEASON_TOKEN_RE.sub(" ", cleaned)
+    title = parse_volume_label(cleaned)
+    return title, season_number

{riplex-0.7.2 → riplex-0.7.4/src/riplex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.7.2
+Version: 0.7.4
 Summary: Automates the tedious manual work around MakeMKV: figuring out what to rip, which MKV files are actually what, and organizing everything into Plex-compatible folder structures.
 License: MIT
 Requires-Python: >=3.11

{riplex-0.7.2 → riplex-0.7.4}/src/riplex.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ docs/getting-started/installation.md
 docs/gui-guide/gui-walkthrough.md
 docs/reference/cli.md
 issues/debug-artifacts-consolidation.md
+issues/manual-rip-and-organize-escape-hatch.md
 issues/orchestrate-dvdcompare-fallback.md
 issues/planned-features.md
 screenshots/0_Rip_Flow_BTTF.gif
@@ -108,11 +109,13 @@ tests/test_disc_detection_screen.py
 tests/test_disc_fixtures.py
 tests/test_disc_provider.py
 tests/test_formatter.py
+tests/test_lookup.py
 tests/test_makemkv.py
 tests/test_matcher.py
 tests/test_normalize.py
 tests/test_organizer.py
 tests/test_planner.py
+tests/test_release_screen.py
 tests/test_rip_guide.py
 tests/test_scanner.py
 tests/test_snapshot.py

{riplex-0.7.2 → riplex-0.7.4}/src/riplex_app/screens/disc_detection.py

@@ -26,11 +26,12 @@ import flet as ft
 from riplex.disc.makemkv import (
     DriveInfo,
     MakeMKV,
+    MakeMKVError,
     MakeMKVPreflight,
     makemkv_preflight,
     run_disc_info,
 )
-from riplex.title import parse_volume_label
+from riplex.title import parse_title_and_season, parse_volume_label
 
 log = logging.getLogger(__name__)
 
@@ -278,6 +279,19 @@ class DiscDetectionScreen:
         try:
             mk = MakeMKV(self.app.state.get("makemkvcon"))
             drives = mk.drive_list()
+        except MakeMKVError as exc:
+            log.warning("makemkvcon refused to list drives (code %s): %s", exc.code, exc)
+            self._show_error(
+                "MakeMKV won\u2019t scan drives",
+                f"makemkvcon reported: {exc}\n\n"
+                "MakeMKV must be updated (or a valid registration key entered) "
+                "before riplex can detect discs. The free beta key is refreshed "
+                "monthly on the MakeMKV forum.",
+                allow_retry=True,
+                install_hint=True,
+                key_hint=True,
+            )
+            return
         except Exception as exc:
             log.warning("drive_list failed: %s", exc)
             if initial:
@@ -439,7 +453,12 @@ class DiscDetectionScreen:
                 return
 
             self.app.state["disc_info"] = disc_info
-            self.app.state["title"] = self._parse_volume_label(drive.disc_label)
+            parsed_title, parsed_season = parse_title_and_season(drive.disc_label)
+            self.app.state["title"] = parsed_title or self._parse_volume_label(drive.disc_label)
+            if parsed_season is not None:
+                self.app.state["season_number"] = parsed_season
+            else:
+                self.app.state.pop("season_number", None)
             self.app.state["_disc_read_done"] = True
 
             async def _nav():
@@ -486,12 +505,19 @@ class DiscDetectionScreen:
         detail: str,
         *,
         allow_retry: bool = True,
+        install_hint: bool = False,
+        key_hint: bool = False,
     ) -> None:
         self.spinner.visible = False
         self.status_text.value = title
         self.status_text.color = ft.Colors.RED
+        self.drive_panel.controls.clear()
         self.error_panel.content = self._build_error_panel(
-            title, detail, allow_retry=allow_retry, install_hint=False,
+            title,
+            detail,
+            allow_retry=allow_retry,
+            install_hint=install_hint,
+            key_hint=key_hint,
         )
         self.error_panel.visible = True
         _safe_update(self.app.page)
@@ -503,6 +529,7 @@ class DiscDetectionScreen:
         *,
         allow_retry: bool,
         install_hint: bool,
+        key_hint: bool = False,
     ) -> ft.Control:
         children: list[ft.Control] = [
             ft.Row(
@@ -535,6 +562,13 @@ class DiscDetectionScreen:
                     url="https://www.makemkv.com/download/",
                 )
             )
+        if key_hint:
+            actions.append(
+                ft.TextButton(
+                    "Get beta key \u2197",
+                    url="https://forum.makemkv.com/forum/viewtopic.php?t=1053",
+                )
+            )
         actions.append(
             ft.OutlinedButton(
                 "Open bug report",

{riplex-0.7.2 → riplex-0.7.4}/src/riplex_app/screens/folder_picker.py

@@ -10,11 +10,11 @@ import flet as ft
 log = logging.getLogger(__name__)
 
 from riplex.config import get_rip_output
-from riplex.detect import detect_format
+from riplex.detect import TitleGroup, detect_format, detect_organize_layout
 from riplex.manifest import build_scanned_from_manifests
 from riplex.scanner import scan_folder
 from riplex.snapshot import load_organized_marker
-from riplex.title import infer_title_from_scanned
+from riplex.title import infer_title_from_scanned, parse_season_number
 
 
 class FolderPickerScreen:
@@ -22,6 +22,10 @@ class FolderPickerScreen:
         self.app = app
 
     def build(self) -> ft.Control:
+        batch_groups = self.app.state.pop("_batch_groups", None)
+        if batch_groups is not None:
+            return self._build_batch_groups_view(batch_groups)
+
         # Check for scan results from background thread
         scan_result = self.app.state.pop("_scan_result", None)
         if scan_result is not None:
@@ -128,6 +132,16 @@ class FolderPickerScreen:
         folder = Path(path)
         self.app.state["source_folder"] = folder
 
+        layout = detect_organize_layout(folder)
+        if layout.mode == "batch":
+            self.app.state["_batch_groups"] = layout.groups
+            self.app.navigate("folder_picker")
+            return
+        if layout.mode == "empty":
+            self.folder_field.error_text = "No MKV files found in that folder."
+            self.folder_field.update()
+            return
+
         # Fast path: if every disc subfolder has a _rip_manifest.json,
         # load metadata from the manifest instead of running ffprobe.
         if self._has_complete_manifests(folder):
@@ -231,6 +245,85 @@ class FolderPickerScreen:
 
         self.app.page.run_task(_nav)
 
+    def _build_batch_groups_view(self, groups: list[TitleGroup]) -> ft.Control:
+        rows: list[ft.Control] = []
+        for group in groups:
+            label = group.title
+            if group.season_number is not None:
+                label = f"{label} Season {group.season_number}"
+            folder_list = ", ".join(folder.name for folder in group.folders)
+            rows.append(
+                ft.Container(
+                    content=ft.Column(
+                        [
+                            ft.Text(label, size=14, weight=ft.FontWeight.BOLD),
+                            ft.Text(folder_list, size=12, color=ft.Colors.GREY_500),
+                            ft.Row(
+                                [
+                                    ft.ElevatedButton(
+                                        "Open",
+                                        icon=ft.Icons.ARROW_FORWARD,
+                                        on_click=lambda _, g=group: self._open_group(g),
+                                    )
+                                ]
+                            ),
+                        ],
+                        spacing=6,
+                    ),
+                    padding=12,
+                    border=ft.Border.all(1, ft.Colors.GREY_800),
+                    border_radius=8,
+                )
+            )
+
+        return ft.Column(
+            [
+                ft.Text("Organize Rips", size=24, weight=ft.FontWeight.BOLD),
+                ft.Text(
+                    "This folder contains multiple organize groups. Pick the one you want to process.",
+                    size=13,
+                    color=ft.Colors.GREY_500,
+                ),
+                ft.Divider(height=20),
+                ft.Column(rows, spacing=10, scroll=ft.ScrollMode.AUTO),
+                ft.Container(expand=True),
+                ft.TextButton("Back", on_click=lambda _: self.app.navigate("welcome")),
+            ],
+            spacing=10,
+            expand=True,
+        )
+
+    def _open_group(self, group: TitleGroup) -> None:
+        if len(group.folders) != 1:
+            # Multi-folder groups still need a shared library batch scanner.
+            self.app.state["_scan_error"] = (
+                "This organize group spans multiple folders. Pick a season folder directly for now."
+            )
+            self.app.navigate("folder_picker")
+            return
+        folder = group.folders[0]
+        self.app.state["source_folder"] = folder
+        self.app.state["title"] = group.title
+        if group.season_number is not None:
+            self.app.state["season_number"] = group.season_number
+        else:
+            self.app.state.pop("season_number", None)
+
+        if self._has_complete_manifests(folder):
+            try:
+                scanned = build_scanned_from_manifests(folder)
+            except Exception:
+                log.exception("manifest load failed; falling back to ffprobe")
+                scanned = None
+            if scanned:
+                self.app.state["_scan_from_manifest"] = True
+                self.app.state["_scan_result"] = scanned
+                self.app.navigate("folder_picker")
+                return
+
+        self.app.state["_scan_from_manifest"] = False
+        self._start_ffprobe_scan(folder)
+
     def _build_results_view(self, scanned) -> ft.Control:
         """Show scan results and let user confirm/edit title."""
         self.app.state["scanned"] = scanned
@@ -307,6 +400,13 @@ class FolderPickerScreen:
             value=inferred,
             width=500,
         )
+        inferred_season = parse_season_number(self.app.state["source_folder"].name)
+        self.season_field = ft.TextField(
+            label="Season number (TV only, optional)",
+            value=str(inferred_season) if inferred_season is not None else "",
+            width=240,
+            hint_text="e.g. 6",
+        )
 
         return ft.Column(
             [
@@ -330,6 +430,8 @@ class FolderPickerScreen:
                 ft.Container(height=10),
                 ft.Text("Detected title:", size=14),
                 self.title_field,
+                ft.Text("Season override:", size=14),
+                self.season_field,
                 ft.Container(expand=True),
                 ft.Row([
                     ft.TextButton("Back", on_click=lambda _: self.app.navigate("welcome")),
@@ -367,5 +469,15 @@ class FolderPickerScreen:
             self.title_field.error_text = "Title is required."
             self.title_field.update()
             return
+        season_text = self.season_field.value.strip() if self.season_field.value else ""
+        if season_text:
+            if not season_text.isdigit() or int(season_text) < 0:
+                self.season_field.error_text = "Enter a valid season number."
+                self.season_field.update()
+                return
+            self.app.state["season_number"] = int(season_text)
+            self.season_field.error_text = None
+        else:
+            self.app.state.pop("season_number", None)
         self.app.state["title"] = title
         self.app.navigate("metadata")

{riplex-0.7.2 → riplex-0.7.4}/src/riplex_app/screens/organize_preview.py

@@ -91,6 +91,7 @@ class OrganizePreviewScreen:
                     request = SearchRequest(
                         title=tmdb_match.title,
                         year=tmdb_match.year,
+                        season_number=self.app.state.get("season_number"),
                         media_type=tmdb_match.media_type,
                     )
                     if tmdb_match.media_type == "movie":