fix: clean up whitespace in ANSI utilities and preview script

viu_media/assets/scripts/fzf/_ansi_utils.py

@@ -0,0 +1,154 @@
+"""
+ANSI utilities for FZF preview scripts.
+
+Lightweight stdlib-only utilities to replace Rich dependency in preview scripts.
+Provides RGB color formatting, table rendering, and markdown stripping.
+"""
+
+import re
+import shutil
+import textwrap
+
+
+def rgb_color(r: int, g: int, b: int, text: str, bold: bool = False) -> str:
+    """
+    Format text with RGB color using ANSI escape codes.
+
+    Args:
+        r: Red component (0-255)
+        g: Green component (0-255)
+        b: Blue component (0-255)
+        text: Text to colorize
+        bold: Whether to make text bold
+
+    Returns:
+        ANSI-escaped colored text
+    """
+    color_code = f"\x1b[38;2;{r};{g};{b}m"
+    bold_code = "\x1b[1m" if bold else ""
+    reset = "\x1b[0m"
+    return f"{color_code}{bold_code}{text}{reset}"
+
+
+def parse_color(color_csv: str) -> tuple[int, int, int]:
+    """
+    Parse RGB color from comma-separated string.
+
+    Args:
+        color_csv: Color as 'R,G,B' string
+
+    Returns:
+        Tuple of (r, g, b) integers
+    """
+    parts = color_csv.split(",")
+    return int(parts[0]), int(parts[1]), int(parts[2])
+
+
+def print_rule(sep_color: str) -> None:
+    """
+    Print a horizontal rule line.
+
+    Args:
+        sep_color: Color as 'R,G,B' string
+    """
+    width = shutil.get_terminal_size((80, 24)).columns
+    r, g, b = parse_color(sep_color)
+    print(rgb_color(r, g, b, "─" * width))
+
+
+def print_table_row(
+    key: str, value: str, header_color: str, key_width: int, value_width: int
+) -> None:
+    """
+    Print a two-column table row with left-aligned key and right-aligned value.
+
+    Args:
+        key: Left column text (header/key)
+        value: Right column text (value)
+        header_color: Color for key as 'R,G,B' string
+        key_width: Width for key column
+        value_width: Width for value column
+    """
+    r, g, b = parse_color(header_color)
+    key_styled = rgb_color(r, g, b, key, bold=True)
+
+    # Ensure minimum width to avoid textwrap errors
+    safe_value_width = max(20, value_width)
+
+    # Wrap value if it's too long
+    value_lines = textwrap.wrap(str(value), width=safe_value_width) if value else [""]
+
+    if not value_lines:
+        value_lines = [""]
+
+    # Print first line with right-aligned value
+    first_line = value_lines[0]
+    print(f"{key_styled:<{key_width + 20}}  {first_line:>{safe_value_width}}")
+
+    # Print remaining wrapped lines (left-aligned, indented)
+    for line in value_lines[1:]:
+        print(f"{' ' * (key_width + 2)}{line}")
+
+
+def strip_markdown(text: str) -> str:
+    """
+    Strip markdown formatting from text.
+
+    Removes:
+    - Headers (# ## ###)
+    - Bold (**text** or __text__)
+    - Italic (*text* or _text_)
+    - Links ([text](url))
+    - Code blocks (```code```)
+    - Inline code (`code`)
+
+    Args:
+        text: Markdown-formatted text
+
+    Returns:
+        Plain text with markdown removed
+    """
+    if not text:
+        return ""
+
+    # Remove code blocks first
+    text = re.sub(r"```[\s\S]*?```", "", text)
+
+    # Remove inline code
+    text = re.sub(r"`([^`]+)`", r"\1", text)
+
+    # Remove headers
+    text = re.sub(r"^#{1,6}\s+", "", text, flags=re.MULTILINE)
+
+    # Remove bold (** or __)
+    text = re.sub(r"\*\*(.+?)\*\*", r"\1", text)
+    text = re.sub(r"__(.+?)__", r"\1", text)
+
+    # Remove italic (* or _)
+    text = re.sub(r"\*(.+?)\*", r"\1", text)
+    text = re.sub(r"_(.+?)_", r"\1", text)
+
+    # Remove links, keep text
+    text = re.sub(r"\[(.+?)\]\(.+?\)", r"\1", text)
+
+    # Remove images
+    text = re.sub(r"!\[.*?\]\(.+?\)", "", text)
+
+    return text.strip()
+
+
+def wrap_text(text: str, width: int | None = None) -> str:
+    """
+    Wrap text to terminal width.
+
+    Args:
+        text: Text to wrap
+        width: Width to wrap to (defaults to terminal width)
+
+    Returns:
+        Wrapped text
+    """
+    if width is None:
+        width = shutil.get_terminal_size((80, 24)).columns
+
+    return textwrap.fill(text, width=width)

viu_media/assets/scripts/fzf/airing_schedule_info.py

@@ -0,0 +1,31 @@
+import sys
+import shutil
+from _ansi_utils import print_rule, print_table_row, strip_markdown, wrap_text
+
+HEADER_COLOR = sys.argv[1]
+SEPARATOR_COLOR = sys.argv[2]
+
+# Get terminal dimensions
+term_width = shutil.get_terminal_size((80, 24)).columns
+
+# Print title centered
+print("{ANIME_TITLE}".center(term_width))
+
+rows = [
+    ("Total Episodes", "{TOTAL_EPISODES}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+rows = [
+    ("Upcoming Episodes", "{UPCOMING_EPISODES}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+print_rule(SEPARATOR_COLOR)
+print(wrap_text(strip_markdown("""{SCHEDULE_TABLE}"""), term_width))

viu_media/assets/scripts/fzf/character_info.py

@@ -0,0 +1,42 @@
+import sys
+import shutil
+from _ansi_utils import print_rule, print_table_row, strip_markdown, wrap_text
+
+HEADER_COLOR = sys.argv[1]
+SEPARATOR_COLOR = sys.argv[2]
+
+# Get terminal dimensions
+term_width = shutil.get_terminal_size((80, 24)).columns
+
+# Print title centered
+print("{CHARACTER_NAME}".center(term_width))
+
+rows = [
+    ("Native Name", "{CHARACTER_NATIVE_NAME}"),
+    ("Gender", "{CHARACTER_GENDER}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+rows = [
+    ("Age", "{CHARACTER_AGE}"),
+    ("Blood Type", "{CHARACTER_BLOOD_TYPE}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+rows = [
+    ("Birthday", "{CHARACTER_BIRTHDAY}"),
+    ("Favourites", "{CHARACTER_FAVOURITES}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+print_rule(SEPARATOR_COLOR)
+print(wrap_text(strip_markdown("""{CHARACTER_DESCRIPTION}"""), term_width))

viu_media/assets/scripts/fzf/episode_info.py

@@ -1,44 +1,50 @@
 import sys
-from rich.console import Console
-from rich.table import Table
-from rich.rule import Rule
-from rich.markdown import Markdown
-
-console = Console(force_terminal=True, color_system="truecolor")
+import shutil
+from _ansi_utils import print_rule, print_table_row
 
 HEADER_COLOR = sys.argv[1]
 SEPARATOR_COLOR = sys.argv[2]
 
+# Get terminal dimensions
+term_width = shutil.get_terminal_size((80, 24)).columns
 
-def rule(title: str | None = None):
-    console.print(Rule(style=f"rgb({SEPARATOR_COLOR})"))
+# Print title centered
+print("{TITLE}".center(term_width))
 
-
-console.print("{TITLE}", justify="center")
-
-left = [
-    ("Duration", "Status"),
-    ("Total Episodes", "Next Episode"),
-    ("Progress", "List Status"),
-    ("Start Date", "End Date"),
-]
-right = [
-    ("{DURATION}", "{STATUS}"),
-    ("{EPISODES}", "{NEXT_EPISODE}"),
-    ("{USER_PROGRESS}", "{USER_STATUS}"),
-    ("{START_DATE}", "{END_DATE}"),
+rows = [
+    ("Duration", "{DURATION}"),
+    ("Status", "{STATUS}"),
 ]
 
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
 
-for L_grp, R_grp in zip(left, right):
-    table = Table.grid(expand=True)
-    table.add_column(justify="left", no_wrap=True)
-    table.add_column(justify="right", overflow="fold")
-    for L, R in zip(L_grp, R_grp):
-        table.add_row(f"[bold rgb({HEADER_COLOR})]{L} [/]", f"{R}")
+rows = [
+    ("Total Episodes", "{EPISODES}"),
+    ("Next Episode", "{NEXT_EPISODE}"),
+]
 
-    rule()
-    console.print(table)
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
 
+rows = [
+    ("Progress", "{USER_PROGRESS}"),
+    ("List Status", "{USER_STATUS}"),
+]
 
-rule()
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+rows = [
+    ("Start Date", "{START_DATE}"),
+    ("End Date", "{END_DATE}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+print_rule(SEPARATOR_COLOR)

viu_media/assets/scripts/fzf/media_info.py

@@ -1,89 +1,88 @@
 import sys
-from rich.console import Console
-from rich.table import Table
-from rich.rule import Rule
-from rich.markdown import Markdown
-
-console = Console(force_terminal=True, color_system="truecolor")
+import shutil
+from _ansi_utils import print_rule, print_table_row, strip_markdown, wrap_text
 
 HEADER_COLOR = sys.argv[1]
 SEPARATOR_COLOR = sys.argv[2]
 
+# Get terminal dimensions
+term_width = shutil.get_terminal_size((80, 24)).columns
 
-def rule(title: str | None = None):
-    console.print(Rule(style=f"rgb({SEPARATOR_COLOR})"))
+# Print title centered
+print("{TITLE}".center(term_width))
 
-
-console.print("{TITLE}", justify="center")
-
-left = [
-    (
-        "Score",
-        "Favorites",
-        "Popularity",
-        "Status",
-    ),
-    (
-        "Episodes",
-        "Duration",
-        "Next Episode",
-    ),
-    (
-        "Genres",
-        "Format",
-    ),
-    (
-        "List Status",
-        "Progress",
-    ),
-    (
-        "Start Date",
-        "End Date",
-    ),
-    ("Studios",),
-    ("Synonymns",),
-    ("Tags",),
-]
-right = [
-    (
-        "{SCORE}",
-        "{FAVOURITES}",
-        "{POPULARITY}",
-        "{STATUS}",
-    ),
-    (
-        "{EPISODES}",
-        "{DURATION}",
-        "{NEXT_EPISODE}",
-    ),
-    (
-        "{GENRES}",
-        "{FORMAT}",
-    ),
-    (
-        "{USER_STATUS}",
-        "{USER_PROGRESS}",
-    ),
-    (
-        "{START_DATE}",
-        "{END_DATE}",
-    ),
-    ("{STUDIOS}",),
-    ("{SYNONYMNS}",),
-    ("{TAGS}",),
+# Define table data
+rows = [
+    ("Score", "{SCORE}"),
+    ("Favorites", "{FAVOURITES}"),
+    ("Popularity", "{POPULARITY}"),
+    ("Status", "{STATUS}"),
 ]
 
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
 
-for L_grp, R_grp in zip(left, right):
-    table = Table.grid(expand=True)
-    table.add_column(justify="left", no_wrap=True)
-    table.add_column(justify="right", overflow="fold")
-    for L, R in zip(L_grp, R_grp):
-        table.add_row(f"[bold rgb({HEADER_COLOR})]{L} [/]", f"{R}")
+rows = [
+    ("Episodes", "{EPISODES}"),
+    ("Duration", "{DURATION}"),
+    ("Next Episode", "{NEXT_EPISODE}"),
+]
 
-    rule()
-    console.print(table)
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
 
+rows = [
+    ("Genres", "{GENRES}"),
+    ("Format", "{FORMAT}"),
+]
 
-rule()
-console.print(Markdown("""{SYNOPSIS}"""))
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+rows = [
+    ("List Status", "{USER_STATUS}"),
+    ("Progress", "{USER_PROGRESS}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+rows = [
+    ("Start Date", "{START_DATE}"),
+    ("End Date", "{END_DATE}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+rows = [
+    ("Studios", "{STUDIOS}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+rows = [
+    ("Synonymns", "{SYNONYMNS}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+rows = [
+    ("Tags", "{TAGS}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+print_rule(SEPARATOR_COLOR)
+print(wrap_text(strip_markdown("""{SYNOPSIS}"""), term_width))

viu_media/assets/scripts/fzf/preview.py

@@ -3,18 +3,16 @@
 # FZF Preview Script Template
 #
 # This script is a template. The placeholders in curly braces, like {NAME}
-#  are dynamically filled by python using .replace()
+# are dynamically filled by python using .replace() during runtime.
 
-from pathlib import Path
-from hashlib import sha256
-import subprocess
 import os
 import shutil
+import subprocess
 import sys
-from rich.console import Console
-from rich.rule import Rule
+from hashlib import sha256
+from pathlib import Path
 
-# dynamically filled variables
+# --- Template Variables (Injected by Python) ---
 PREVIEW_MODE = "{PREVIEW_MODE}"
 IMAGE_CACHE_DIR = Path("{IMAGE_CACHE_DIR}")
 INFO_CACHE_DIR = Path("{INFO_CACHE_DIR}")
@@ -24,191 +22,266 @@ SEPARATOR_COLOR = "{SEPARATOR_COLOR}"
 PREFIX = "{PREFIX}"
 SCALE_UP = "{SCALE_UP}" == "True"
 
-# fzf passes the title with quotes, so we need to trim them
-TITLE = sys.argv[1]
+# --- Arguments ---
+# sys.argv[1] is usually the raw line from FZF (the anime title/key)
+TITLE = sys.argv[1] if len(sys.argv) > 1 else ""
 KEY = """{KEY}"""
 KEY = KEY + "-" if KEY else KEY
 
-hash = f"{PREFIX}-{sha256((KEY + TITLE).encode('utf-8')).hexdigest()}"
+# Generate the hash to find the cached files
+hash_id = f"{PREFIX}-{sha256((KEY + TITLE).encode('utf-8')).hexdigest()}"
+
+
+def get_terminal_dimensions():
+    """
+    Determine the available dimensions (cols x lines) for the preview window.
+    Prioritizes FZF environment variables.
+    """
+    fzf_cols = os.environ.get("FZF_PREVIEW_COLUMNS")
+    fzf_lines = os.environ.get("FZF_PREVIEW_LINES")
+
+    if fzf_cols and fzf_lines:
+        return int(fzf_cols), int(fzf_lines)
+
+    # Fallback to stty if FZF vars aren't set (unlikely in preview)
+    try:
+        rows, cols = (
+            subprocess.check_output(
+                ["stty", "size"], text=True, stderr=subprocess.DEVNULL
+            )
+            .strip()
+            .split()
+        )
+        return int(cols), int(rows)
+    except Exception:
+        return 80, 24
+
+
+def which(cmd):
+    """Alias for shutil.which"""
+    return shutil.which(cmd)
+
+
+def render_kitty(file_path, width, height, scale_up):
+    """Render using the Kitty Graphics Protocol (kitten/icat)."""
+    # 1. Try 'kitten icat' (Modern)
+    # 2. Try 'icat' (Legacy/Alias)
+    # 3. Try 'kitty +kitten icat' (Fallback)
+
+    cmd = []
+    if which("kitten"):
+        cmd = ["kitten", "icat"]
+    elif which("icat"):
+        cmd = ["icat"]
+    elif which("kitty"):
+        cmd = ["kitty", "+kitten", "icat"]
+
+    if not cmd:
+        return False
+
+    # Build Arguments
+    args = [
+        "--clear",
+        "--transfer-mode=memory",
+        "--unicode-placeholder",
+        "--stdin=no",
+        f"--place={width}x{height}@0x0",
+    ]
+
+    if scale_up:
+        args.append("--scale-up")
+
+    args.append(file_path)
+
+    subprocess.run(cmd + args, stdout=sys.stdout, stderr=sys.stderr)
+    return True
+
+
+def render_sixel(file_path, width, height):
+    """
+    Render using Sixel.
+    Prioritizes 'chafa' for Sixel as it handles text-cell sizing better than img2sixel.
+    """
+
+    # Option A: Chafa (Best for Sixel sizing)
+    if which("chafa"):
+        # Chafa automatically detects Sixel support if terminal reports it,
+        # but we force it here if specifically requested via logic flow.
+        subprocess.run(
+            ["chafa", "-f", "sixel", "-s", f"{width}x{height}", file_path],
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+        return True
+
+    # Option B: img2sixel (Libsixel)
+    # Note: img2sixel uses pixels, not cells. We estimate 1 cell ~= 10px width, 20px height
+    if which("img2sixel"):
+        pixel_width = width * 10
+        pixel_height = height * 20
+        subprocess.run(
+            [
+                "img2sixel",
+                f"--width={pixel_width}",
+                f"--height={pixel_height}",
+                file_path,
+            ],
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+        return True
+
+    return False
+
+
+def render_iterm(file_path, width, height):
+    """Render using iTerm2 Inline Image Protocol."""
+    if which("imgcat"):
+        subprocess.run(
+            ["imgcat", "-W", str(width), "-H", str(height), file_path],
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+        return True
+
+    # Chafa also supports iTerm
+    if which("chafa"):
+        subprocess.run(
+            ["chafa", "-f", "iterm", "-s", f"{width}x{height}", file_path],
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+        return True
+    return False
+
+
+def render_timg(file_path, width, height):
+    """Render using timg (supports half-blocks, quarter-blocks, sixel, kitty, etc)."""
+    if which("timg"):
+        subprocess.run(
+            ["timg", f"-g{width}x{height}", "--upscale", file_path],
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+        return True
+    return False
+
+
+def render_chafa_auto(file_path, width, height):
+    """
+    Render using Chafa in auto mode.
+    It supports Sixel, Kitty, iTerm, and various unicode block modes.
+    """
+    if which("chafa"):
+        subprocess.run(
+            ["chafa", "-s", f"{width}x{height}", file_path],
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+        return True
+    return False
 
 
 def fzf_image_preview(file_path: str):
-    # Environment variables from fzf
-    FZF_PREVIEW_COLUMNS = os.environ.get("FZF_PREVIEW_COLUMNS")
-    FZF_PREVIEW_LINES = os.environ.get("FZF_PREVIEW_LINES")
-    FZF_PREVIEW_TOP = os.environ.get("FZF_PREVIEW_TOP")
-    KITTY_WINDOW_ID = os.environ.get("KITTY_WINDOW_ID")
-    GHOSTTY_BIN_DIR = os.environ.get("GHOSTTY_BIN_DIR")
-    PLATFORM = os.environ.get("PLATFORM")
+    """
+    Main dispatch function to choose the best renderer.
+    """
+    cols, lines = get_terminal_dimensions()
 
-    # Compute terminal dimensions
-    dim = (
-        f"{FZF_PREVIEW_COLUMNS}x{FZF_PREVIEW_LINES}"
-        if FZF_PREVIEW_COLUMNS and FZF_PREVIEW_LINES
-        else "x"
-    )
+    # Heuristic: Reserve 1 line for prompt/status if needed, though FZF handles this.
+    # Some renderers behave better with a tiny bit of padding.
+    width = cols
+    height = lines
 
-    if dim == "x":
-        try:
-            rows, cols = (
-                subprocess.check_output(
-                    ["stty", "size"], text=True, stderr=subprocess.DEVNULL
-                )
-                .strip()
-                .split()
+    # --- 1. Check Explicit Configuration ---
+
+    if IMAGE_RENDERER == "icat" or IMAGE_RENDERER == "system-kitty":
+        if render_kitty(file_path, width, height, SCALE_UP):
+            return
+
+    elif IMAGE_RENDERER == "sixel" or IMAGE_RENDERER == "system-sixels":
+        if render_sixel(file_path, width, height):
+            return
+
+    elif IMAGE_RENDERER == "imgcat":
+        if render_iterm(file_path, width, height):
+            return
+
+    elif IMAGE_RENDERER == "timg":
+        if render_timg(file_path, width, height):
+            return
+
+    elif IMAGE_RENDERER == "chafa":
+        if render_chafa_auto(file_path, width, height):
+            return
+
+    # --- 2. Auto-Detection / Fallback Strategy ---
+
+    # If explicit failed or set to 'auto'/'system-default', try detecting environment
+
+    # Ghostty / Kitty Environment
+    if os.environ.get("KITTY_WINDOW_ID") or os.environ.get("GHOSTTY_BIN_DIR"):
+        if render_kitty(file_path, width, height, SCALE_UP):
+            return
+
+    # iTerm Environment
+    if os.environ.get("TERM_PROGRAM") == "iTerm.app":
+        if render_iterm(file_path, width, height):
+            return
+
+    # Try standard tools in order of quality/preference
+    if render_kitty(file_path, width, height, SCALE_UP):
+        return  # Try kitty just in case
+    if render_sixel(file_path, width, height):
+        return
+    if render_timg(file_path, width, height):
+        return
+    if render_chafa_auto(file_path, width, height):
+        return
+
+    print("⚠️ No suitable image renderer found (icat, chafa, timg, img2sixel).")
+
+
+def fzf_text_info_render():
+    """Renders the text-based info via the cached python script."""
+    import shutil
+
+    # Print simple separator line
+    width = shutil.get_terminal_size((80, 24)).columns
+    r, g, b = map(int, SEPARATOR_COLOR.split(","))
+    print(f"\x1b[38;2;{r};{g};{b}m" + "─" * width + "\x1b[0m")
+
+    if PREVIEW_MODE == "text" or PREVIEW_MODE == "full":
+        preview_info_path = INFO_CACHE_DIR / f"{hash_id}.py"
+        if preview_info_path.exists():
+            subprocess.run(
+                [sys.executable, str(preview_info_path), HEADER_COLOR, SEPARATOR_COLOR]
             )
-            dim = f"{cols}x{rows}"
-        except Exception:
-            dim = "80x24"
+        else:
+            # Print dim text
+            print("\x1b[2m📝 Loading details...\x1b[0m")
 
-    # Adjust dimension if icat not used and preview area fills bottom of screen
-    if (
-        IMAGE_RENDERER != "icat"
-        and not KITTY_WINDOW_ID
-        and FZF_PREVIEW_TOP
-        and FZF_PREVIEW_LINES
+
+def main():
+    # 1. Image Preview
+    if (PREVIEW_MODE == "image" or PREVIEW_MODE == "full") and (
+        PREFIX not in ("character", "review", "airing-schedule")
     ):
-        try:
-            term_rows = int(
-                subprocess.check_output(["stty", "size"], text=True).split()[0]
-            )
-            if int(FZF_PREVIEW_TOP) + int(FZF_PREVIEW_LINES) == term_rows:
-                dim = f"{FZF_PREVIEW_COLUMNS}x{int(FZF_PREVIEW_LINES) - 1}"
-        except Exception:
-            pass
-
-    # Helper to run commands
-    def run(cmd):
-        subprocess.run(cmd, stdout=sys.stdout, stderr=sys.stderr)
-
-    def command_exists(cmd):
-        return shutil.which(cmd) is not None
-
-    # ICAT / KITTY path
-    if IMAGE_RENDERER == "icat" and not GHOSTTY_BIN_DIR:
-        icat_cmd = None
-        if command_exists("kitten"):
-            icat_cmd = ["kitten", "icat"]
-        elif command_exists("icat"):
-            icat_cmd = ["icat"]
-        elif command_exists("kitty"):
-            icat_cmd = ["kitty", "icat"]
-
-        if icat_cmd:
-            run(
-                icat_cmd
-                + [
-                    "--clear",
-                    "--transfer-mode=memory",
-                    "--unicode-placeholder",
-                    "--stdin=no",
-                    f"--place={dim}@0x0",
-                    file_path,
-                ]
-            )
+        preview_image_path = IMAGE_CACHE_DIR / f"{hash_id}.png"
+        if preview_image_path.exists():
+            fzf_image_preview(str(preview_image_path))
+            print()  # Spacer
         else:
-            print("No icat-compatible viewer found (kitten/icat/kitty)")
+            print("🖼️  Loading image...")
 
-    elif GHOSTTY_BIN_DIR:
-        try:
-            cols = int(FZF_PREVIEW_COLUMNS or "80") - 1
-            lines = FZF_PREVIEW_LINES or "24"
-            dim = f"{cols}x{lines}"
-        except Exception:
-            pass
-
-        if command_exists("kitten"):
-            run(
-                [
-                    "kitten",
-                    "icat",
-                    "--clear",
-                    "--transfer-mode=memory",
-                    "--unicode-placeholder",
-                    "--stdin=no",
-                    f"--place={dim}@0x0",
-                    file_path,
-                ]
-            )
-        elif command_exists("icat"):
-            run(
-                [
-                    "icat",
-                    "--clear",
-                    "--transfer-mode=memory",
-                    "--unicode-placeholder",
-                    "--stdin=no",
-                    f"--place={dim}@0x0",
-                    file_path,
-                ]
-            )
-        elif command_exists("chafa"):
-            run(["chafa", "-s", dim, file_path])
-
-    elif command_exists("chafa"):
-        # Platform specific rendering
-        if PLATFORM == "android":
-            run(["chafa", "-s", dim, file_path])
-        elif PLATFORM == "windows":
-            run(["chafa", "-f", "sixel", "-s", dim, file_path])
-        else:
-            run(["chafa", "-s", dim, file_path])
-        print()
-
-    elif command_exists("imgcat"):
-        width, height = dim.split("x")
-        run(["imgcat", "-W", width, "-H", height, file_path])
-
-    else:
-        print(
-            "⚠️ Please install a terminal image viewer (icat, kitten, imgcat, or chafa)."
-        )
+    # 2. Text Info Preview
+    fzf_text_info_render()
 
 
-def fzf_text_preview(file_path: str):
-    from base64 import standard_b64encode
-
-    def serialize_gr_command(**cmd):
-        payload = cmd.pop("payload", None)
-        cmd = ",".join(f"{k}={v}" for k, v in cmd.items())
-        ans = []
-        w = ans.append
-        w(b"\033_G")
-        w(cmd.encode("ascii"))
-        if payload:
-            w(b";")
-            w(payload)
-        w(b"\033\\")
-        return b"".join(ans)
-
-    def write_chunked(**cmd):
-        data = standard_b64encode(cmd.pop("data"))
-        while data:
-            chunk, data = data[:4096], data[4096:]
-            m = 1 if data else 0
-            sys.stdout.buffer.write(serialize_gr_command(payload=chunk, m=m, **cmd))
-            sys.stdout.flush()
-            cmd.clear()
-
-    with open(file_path, "rb") as f:
-        write_chunked(a="T", f=100, data=f.read())
-
-
-console = Console(force_terminal=True, color_system="truecolor")
-if PREVIEW_MODE == "image" or PREVIEW_MODE == "full":
-    preview_image_path = IMAGE_CACHE_DIR / f"{hash}.png"
-    if preview_image_path.exists():
-        fzf_image_preview(str(preview_image_path))
-        print()
-    else:
-        print("🖼️  Loading image...")
-
-console.print(Rule(style=f"rgb({SEPARATOR_COLOR})"))
-if PREVIEW_MODE == "text" or PREVIEW_MODE == "full":
-    preview_info_path = INFO_CACHE_DIR / f"{hash}.py"
-    if preview_info_path.exists():
-        subprocess.run(
-            [sys.executable, str(preview_info_path), HEADER_COLOR, SEPARATOR_COLOR]
-        )
-    else:
-        console.print("📝 Loading details...")
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        print(f"Preview Error: {e}")

viu_media/assets/scripts/fzf/review_info.py

@@ -0,0 +1,23 @@
+import sys
+import shutil
+from _ansi_utils import print_rule, print_table_row, strip_markdown, wrap_text
+
+HEADER_COLOR = sys.argv[1]
+SEPARATOR_COLOR = sys.argv[2]
+
+# Get terminal dimensions
+term_width = shutil.get_terminal_size((80, 24)).columns
+
+# Print title centered
+print("{REVIEWER_NAME}".center(term_width))
+
+rows = [
+    ("Summary", "{REVIEW_SUMMARY}"),
+]
+
+print_rule(SEPARATOR_COLOR)
+for key, value in rows:
+    print_table_row(key, value, HEADER_COLOR, 15, term_width - 20)
+
+print_rule(SEPARATOR_COLOR)
+print(wrap_text(strip_markdown("""{REVIEW_BODY}"""), term_width))

viu_media/cli/utils/preview.py

@@ -124,15 +124,9 @@ logger = logging.getLogger(__name__)
 PREVIEWS_CACHE_DIR = APP_CACHE_DIR / "previews"
 IMAGES_CACHE_DIR = PREVIEWS_CACHE_DIR / "images"
 INFO_CACHE_DIR = PREVIEWS_CACHE_DIR / "info"
-REVIEWS_CACHE_DIR = PREVIEWS_CACHE_DIR / "reviews"
-CHARACTERS_CACHE_DIR = PREVIEWS_CACHE_DIR / "characters"
-AIRING_SCHEDULE_CACHE_DIR = PREVIEWS_CACHE_DIR / "airing_schedule"
 
 FZF_SCRIPTS_DIR = SCRIPTS_DIR / "fzf"
 TEMPLATE_PREVIEW_SCRIPT = (FZF_SCRIPTS_DIR / "preview.py").read_text(encoding="utf-8")
-TEMPLATE_REVIEW_PREVIEW_SCRIPT = ""
-TEMPLATE_CHARACTER_PREVIEW_SCRIPT = ""
-TEMPLATE_AIRING_SCHEDULE_PREVIEW_SCRIPT = ""
 DYNAMIC_PREVIEW_SCRIPT = ""
 
 EPISODE_PATTERN = re.compile(r"^Episode\s+(\d+)\s-\s.*")
@@ -141,6 +135,23 @@ EPISODE_PATTERN = re.compile(r"^Episode\s+(\d+)\s-\s.*")
 _preview_manager: Optional[PreviewWorkerManager] = None
 
 
+def _ensure_ansi_utils_in_cache():
+    """Copy _ansi_utils.py to the info cache directory so cached scripts can import it."""
+    source = FZF_SCRIPTS_DIR / "_ansi_utils.py"
+    dest = INFO_CACHE_DIR / "_ansi_utils.py"
+
+    if source.exists() and (
+        not dest.exists() or source.stat().st_mtime > dest.stat().st_mtime
+    ):
+        try:
+            import shutil
+
+            shutil.copy2(source, dest)
+            logger.debug(f"Copied _ansi_utils.py to {INFO_CACHE_DIR}")
+        except Exception as e:
+            logger.warning(f"Failed to copy _ansi_utils.py to cache: {e}")
+
+
 def create_preview_context():
     """
     Create a context manager for preview operations.
@@ -276,6 +287,7 @@ def get_anime_preview(
     # Ensure cache directories exist on startup
     IMAGES_CACHE_DIR.mkdir(parents=True, exist_ok=True)
     INFO_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    _ensure_ansi_utils_in_cache()
 
     HEADER_COLOR = config.fzf.preview_header_color.split(",")
     SEPARATOR_COLOR = config.fzf.preview_separator_color.split(",")
@@ -309,11 +321,10 @@ def get_anime_preview(
     for key, value in replacements.items():
         preview_script = preview_script.replace(f"{{{key}}}", value)
 
-    (PREVIEWS_CACHE_DIR / "search-result-preview-script.py").write_text(
-        preview_script, encoding="utf-8"
-    )
+    preview_file = PREVIEWS_CACHE_DIR / "search-result-preview-script.py"
+    preview_file.write_text(preview_script, encoding="utf-8")
 
-    preview_script_final = f"{sys.executable} {PREVIEWS_CACHE_DIR / 'search-result-preview-script.py'} {{}}"
+    preview_script_final = f"{sys.executable} {preview_file} {{}}"
     return preview_script_final
 
 
@@ -368,15 +379,154 @@ def get_episode_preview(
     for key, value in replacements.items():
         preview_script = preview_script.replace(f"{{{key}}}", value)
 
-    (PREVIEWS_CACHE_DIR / "episode-preview-script.py").write_text(
-        preview_script, encoding="utf-8"
-    )
-    preview_script_final = (
-        f"{sys.executable} {PREVIEWS_CACHE_DIR / 'episode-preview-script.py'} {{}}"
-    )
+    preview_file = PREVIEWS_CACHE_DIR / "episode-preview-script.py"
+    preview_file.write_text(preview_script, encoding="utf-8")
+
+    preview_script_final = f"{sys.executable} {preview_file} {{}}"
     return preview_script_final
 
 
+def get_character_preview(choice_map: Dict[str, Character], config: AppConfig) -> str:
+    """
+    Generate the generic loader script for character previews and start background caching.
+    """
+
+    IMAGES_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    INFO_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    HEADER_COLOR = config.fzf.preview_header_color.split(",")
+    SEPARATOR_COLOR = config.fzf.preview_separator_color.split(",")
+
+    # Start managed background caching for episodes
+    try:
+        preview_manager = _get_preview_manager()
+        worker = preview_manager.get_character_worker()
+        worker.cache_character_previews(choice_map, config)
+        logger.debug("Started background caching for character previews")
+    except Exception as e:
+        logger.error(f"Failed to start episode background caching: {e}")
+
+    # Use the generic loader script
+    preview_script = TEMPLATE_PREVIEW_SCRIPT
+
+    replacements = {
+        "PREVIEW_MODE": config.general.preview,
+        "IMAGE_CACHE_DIR": str(IMAGES_CACHE_DIR),
+        "INFO_CACHE_DIR": str(INFO_CACHE_DIR),
+        "IMAGE_RENDERER": config.general.image_renderer,
+        # Color codes
+        "HEADER_COLOR": ",".join(HEADER_COLOR),
+        "SEPARATOR_COLOR": ",".join(SEPARATOR_COLOR),
+        "PREFIX": "character",
+        "KEY": "",
+        "SCALE_UP": str(config.general.preview_scale_up),
+    }
+
+    for key, value in replacements.items():
+        preview_script = preview_script.replace(f"{{{key}}}", value)
+
+    preview_file = PREVIEWS_CACHE_DIR / "character-preview-script.py"
+    preview_file.write_text(preview_script, encoding="utf-8")
+
+    preview_script_final = f"{sys.executable} {preview_file} {{}}"
+    return preview_script_final
+
+
+def get_review_preview(choice_map: Dict[str, MediaReview], config: AppConfig) -> str:
+    """
+    Generate the generic loader script for review previews and start background caching.
+    """
+
+    IMAGES_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    INFO_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    HEADER_COLOR = config.fzf.preview_header_color.split(",")
+    SEPARATOR_COLOR = config.fzf.preview_separator_color.split(",")
+
+    # Start managed background caching for episodes
+    try:
+        preview_manager = _get_preview_manager()
+        worker = preview_manager.get_review_worker()
+        worker.cache_review_previews(choice_map, config)
+        logger.debug("Started background caching for review previews")
+    except Exception as e:
+        logger.error(f"Failed to start episode background caching: {e}")
+
+    # Use the generic loader script
+    preview_script = TEMPLATE_PREVIEW_SCRIPT
+
+    replacements = {
+        "PREVIEW_MODE": config.general.preview,
+        "IMAGE_CACHE_DIR": str(IMAGES_CACHE_DIR),
+        "INFO_CACHE_DIR": str(INFO_CACHE_DIR),
+        "IMAGE_RENDERER": config.general.image_renderer,
+        # Color codes
+        "HEADER_COLOR": ",".join(HEADER_COLOR),
+        "SEPARATOR_COLOR": ",".join(SEPARATOR_COLOR),
+        "PREFIX": "review",
+        "KEY": "",
+        "SCALE_UP": str(config.general.preview_scale_up),
+    }
+
+    for key, value in replacements.items():
+        preview_script = preview_script.replace(f"{{{key}}}", value)
+
+    preview_file = PREVIEWS_CACHE_DIR / "review-preview-script.py"
+    preview_file.write_text(preview_script, encoding="utf-8")
+
+    preview_script_final = f"{sys.executable} {preview_file} {{}}"
+    return preview_script_final
+
+
+def get_airing_schedule_preview(
+    schedule_result: AiringScheduleResult, config: AppConfig, anime_title: str = "Anime"
+) -> str:
+    """
+    Generate the generic loader script for airing schedule previews and start background caching.
+    """
+
+    IMAGES_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    INFO_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    HEADER_COLOR = config.fzf.preview_header_color.split(",")
+    SEPARATOR_COLOR = config.fzf.preview_separator_color.split(",")
+
+    # Start managed background caching for episodes
+    try:
+        preview_manager = _get_preview_manager()
+        worker = preview_manager.get_airing_schedule_worker()
+        worker.cache_airing_schedule_preview(anime_title, schedule_result, config)
+        logger.debug("Started background caching for airing schedule previews")
+    except Exception as e:
+        logger.error(f"Failed to start episode background caching: {e}")
+
+    # Use the generic loader script
+    preview_script = TEMPLATE_PREVIEW_SCRIPT
+
+    replacements = {
+        "PREVIEW_MODE": config.general.preview,
+        "IMAGE_CACHE_DIR": str(IMAGES_CACHE_DIR),
+        "INFO_CACHE_DIR": str(INFO_CACHE_DIR),
+        "IMAGE_RENDERER": config.general.image_renderer,
+        # Color codes
+        "HEADER_COLOR": ",".join(HEADER_COLOR),
+        "SEPARATOR_COLOR": ",".join(SEPARATOR_COLOR),
+        "PREFIX": "airing-schedule",
+        "KEY": "",
+        "SCALE_UP": str(config.general.preview_scale_up),
+    }
+
+    for key, value in replacements.items():
+        preview_script = preview_script.replace(f"{{{key}}}", value)
+
+    preview_file = PREVIEWS_CACHE_DIR / "airing-schedule-preview-script.py"
+    preview_file.write_text(preview_script, encoding="utf-8")
+
+    preview_script_final = f"{sys.executable} {preview_file} {{}}"
+    # NOTE: disabled cause not very useful
+    return ""
+
+
 def get_dynamic_anime_preview(config: AppConfig) -> str:
     """
     Generate dynamic anime preview script for search functionality.
@@ -395,6 +545,7 @@ def get_dynamic_anime_preview(config: AppConfig) -> str:
     # Ensure cache directories exist
     IMAGES_CACHE_DIR.mkdir(parents=True, exist_ok=True)
     INFO_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    _ensure_ansi_utils_in_cache()
 
     HEADER_COLOR = config.fzf.preview_header_color.split(",")
     SEPARATOR_COLOR = config.fzf.preview_separator_color.split(",")
@@ -435,9 +586,7 @@ def _get_preview_manager() -> PreviewWorkerManager:
     """Get or create the global preview worker manager."""
     global _preview_manager
     if _preview_manager is None:
-        _preview_manager = PreviewWorkerManager(
-            IMAGES_CACHE_DIR, INFO_CACHE_DIR, REVIEWS_CACHE_DIR
-        )
+        _preview_manager = PreviewWorkerManager(IMAGES_CACHE_DIR, INFO_CACHE_DIR)
     return _preview_manager
 
 
@@ -461,111 +610,3 @@ def get_preview_worker_status() -> dict:
     if _preview_manager:
         return _preview_manager.get_status()
     return {"preview_worker": None, "episode_worker": None}
-
-
-def get_review_preview(choice_map: Dict[str, MediaReview], config: AppConfig) -> str:
-    """
-    Generate the generic loader script for review previews and start background caching.
-    """
-
-    REVIEWS_CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    preview_manager = _get_preview_manager()
-    worker = preview_manager.get_review_worker()
-    worker.cache_review_previews(choice_map, config)
-    logger.debug("Started background caching for review previews")
-
-    # Use the generic loader script
-    preview_script = TEMPLATE_REVIEW_PREVIEW_SCRIPT
-    path_sep = "\\" if PLATFORM == "win32" else "/"
-
-    # Inject the correct cache path and color codes
-    replacements = {
-        "PREVIEW_MODE": config.general.preview,
-        "INFO_CACHE_DIR": str(REVIEWS_CACHE_DIR),
-        "PATH_SEP": path_sep,
-        "C_TITLE": ansi.get_true_fg(config.fzf.header_color.split(","), bold=True),
-        "C_KEY": ansi.get_true_fg(config.fzf.header_color.split(","), bold=True),
-        "C_VALUE": ansi.get_true_fg(config.fzf.header_color.split(","), bold=True),
-        "C_RULE": ansi.get_true_fg(
-            config.fzf.preview_separator_color.split(","), bold=True
-        ),
-        "RESET": ansi.RESET,
-    }
-
-    for key, value in replacements.items():
-        preview_script = preview_script.replace(f"{{{key}}}", value)
-
-    return preview_script
-
-
-def get_character_preview(choice_map: Dict[str, Character], config: AppConfig) -> str:
-    """
-    Generate the generic loader script for character previews and start background caching.
-    """
-
-    INFO_CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    preview_manager = _get_preview_manager()
-    worker = preview_manager.get_character_worker()
-    worker.cache_character_previews(choice_map, config)
-    logger.debug("Started background caching for character previews")
-
-    # Use the generic loader script
-    preview_script = TEMPLATE_CHARACTER_PREVIEW_SCRIPT
-    path_sep = "\\" if PLATFORM == "win32" else "/"
-
-    # Inject the correct cache path and color codes
-    replacements = {
-        "PREVIEW_MODE": config.general.preview,
-        "INFO_CACHE_DIR": str(INFO_CACHE_DIR),
-        "IMAGE_CACHE_DIR": str(IMAGES_CACHE_DIR),
-        "PATH_SEP": path_sep,
-        "C_TITLE": ansi.get_true_fg(config.fzf.header_color.split(","), bold=True),
-        "C_KEY": ansi.get_true_fg(config.fzf.header_color.split(","), bold=True),
-        "C_VALUE": ansi.get_true_fg(config.fzf.header_color.split(","), bold=True),
-        "C_RULE": ansi.get_true_fg(
-            config.fzf.preview_separator_color.split(","), bold=True
-        ),
-        "RESET": ansi.RESET,
-    }
-
-    for key, value in replacements.items():
-        preview_script = preview_script.replace(f"{{{key}}}", value)
-
-    return preview_script
-
-
-def get_airing_schedule_preview(
-    schedule_result: AiringScheduleResult, config: AppConfig, anime_title: str = "Anime"
-) -> str:
-    """
-    Generate the generic loader script for airing schedule previews and start background caching.
-    """
-
-    INFO_CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    preview_manager = _get_preview_manager()
-    worker = preview_manager.get_airing_schedule_worker()
-    worker.cache_airing_schedule_preview(anime_title, schedule_result, config)
-    logger.debug("Started background caching for airing schedule previews")
-
-    # Use the generic loader script
-    preview_script = TEMPLATE_AIRING_SCHEDULE_PREVIEW_SCRIPT
-    path_sep = "\\" if PLATFORM == "win32" else "/"
-
-    # Inject the correct cache path and color codes
-    replacements = {
-        "PREVIEW_MODE": config.general.preview,
-        "INFO_CACHE_DIR": str(INFO_CACHE_DIR),
-        "PATH_SEP": path_sep,
-        "C_TITLE": ansi.get_true_fg(config.fzf.header_color.split(","), bold=True),
-        "C_KEY": ansi.get_true_fg(config.fzf.header_color.split(","), bold=True),
-        "C_VALUE": ansi.get_true_fg(config.fzf.header_color.split(","), bold=True),
-        "C_RULE": ansi.get_true_fg(
-            config.fzf.preview_separator_color.split(","), bold=True
-        ),
-        "RESET": ansi.RESET,
-    }
-
-    for key, value in replacements.items():
-        preview_script = preview_script.replace(f"{{{key}}}", value)
-
-    return preview_script

viu_media/cli/utils/preview_workers.py

@@ -6,6 +6,7 @@ including image downloads and info text generation with proper lifecycle managem
 """
 
 import logging
+from pathlib import Path
 from typing import Dict, List, Optional
 
 import httpx
@@ -359,7 +360,7 @@ class EpisodeCacheWorker(ManagedBackgroundWorker):
         replacements = {
             "TITLE": formatter.shell_safe(title),
             "NEXT_EPISODE": formatter.shell_safe(
-                f"Episode {media_item.next_airing.episode} on {formatter.format_date(media_item.next_airing.airing_at, '%A, %d %B %Y at %X)')}"
+                f"Episode {media_item.next_airing.episode} on {formatter.format_date(media_item.next_airing.airing_at, '%A, %d %B %Y at %X')}"
                 if media_item.next_airing
                 else "N/A"
             ),
@@ -392,7 +393,7 @@ class EpisodeCacheWorker(ManagedBackgroundWorker):
     def _save_info_text(self, info_text: str, hash_id: str) -> None:
         """Save episode info text to cache."""
         try:
-            info_path = self.info_cache_dir / hash_id
+            info_path = self.info_cache_dir / (hash_id + ".py")
             with AtomicWriter(info_path) as f:
                 f.write(info_text)
             logger.debug(f"Successfully cached episode info: {hash_id}")
@@ -421,9 +422,12 @@ class ReviewCacheWorker(ManagedBackgroundWorker):
     Specialized background worker for caching fully-rendered media review previews.
     """
 
-    def __init__(self, reviews_cache_dir, max_workers: int = 10):
+    def __init__(
+        self, images_cache_dir: Path, info_cache_dir: Path, max_workers: int = 10
+    ):
         super().__init__(max_workers=max_workers, name="ReviewCacheWorker")
-        self.reviews_cache_dir = reviews_cache_dir
+        self.images_cache_dir = images_cache_dir
+        self.info_cache_dir = info_cache_dir
 
     def cache_review_previews(
         self, choice_map: Dict[str, MediaReview], config: AppConfig
@@ -471,7 +475,7 @@ class ReviewCacheWorker(ManagedBackgroundWorker):
     def _save_preview_content(self, content: str, hash_id: str) -> None:
         """Saves the final preview content to the cache."""
         try:
-            info_path = self.reviews_cache_dir / hash_id
+            info_path = self.info_cache_dir / hash_id
             with AtomicWriter(info_path) as f:
                 f.write(content)
             logger.debug(f"Successfully cached review preview: {hash_id}")
@@ -482,7 +486,7 @@ class ReviewCacheWorker(ManagedBackgroundWorker):
     def _get_cache_hash(self, text: str) -> str:
         from hashlib import sha256
 
-        return sha256(text.encode("utf-8")).hexdigest()
+        return "review-" + sha256(text.encode("utf-8")).hexdigest() + ".py"
 
     def _on_task_completed(self, task: WorkerTask, future) -> None:
         super()._on_task_completed(task, future)
@@ -617,7 +621,7 @@ class CharacterCacheWorker(ManagedBackgroundWorker):
     def _get_cache_hash(self, text: str) -> str:
         from hashlib import sha256
 
-        return sha256(text.encode("utf-8")).hexdigest()
+        return "character-" + sha256(text.encode("utf-8")).hexdigest() + ".py"
 
     def _on_task_completed(self, task: WorkerTask, future) -> None:
         super()._on_task_completed(task, future)
@@ -741,7 +745,7 @@ class AiringScheduleCacheWorker(ManagedBackgroundWorker):
     def _get_cache_hash(self, text: str) -> str:
         from hashlib import sha256
 
-        return sha256(text.encode("utf-8")).hexdigest()
+        return "airing-schedule-" + sha256(text.encode("utf-8")).hexdigest() + ".py"
 
     def _on_task_completed(self, task: WorkerTask, future) -> None:
         super()._on_task_completed(task, future)
@@ -757,7 +761,7 @@ class PreviewWorkerManager:
     caching workers with automatic lifecycle management.
     """
 
-    def __init__(self, images_cache_dir, info_cache_dir, reviews_cache_dir):
+    def __init__(self, images_cache_dir, info_cache_dir):
         """
         Initialize the preview worker manager.
 
@@ -768,7 +772,6 @@ class PreviewWorkerManager:
         """
         self.images_cache_dir = images_cache_dir
         self.info_cache_dir = info_cache_dir
-        self.reviews_cache_dir = reviews_cache_dir
         self._preview_worker: Optional[PreviewCacheWorker] = None
         self._episode_worker: Optional[EpisodeCacheWorker] = None
         self._review_worker: Optional[ReviewCacheWorker] = None
@@ -812,7 +815,9 @@ class PreviewWorkerManager:
                 # Clean up old worker
                 thread_manager.shutdown_worker("review_cache_worker")
 
-            self._review_worker = ReviewCacheWorker(self.reviews_cache_dir)
+            self._review_worker = ReviewCacheWorker(
+                self.images_cache_dir, self.info_cache_dir
+            )
             self._review_worker.start()
             thread_manager.register_worker("review_cache_worker", self._review_worker)
 

viu_media/core/config/model.py

@@ -178,7 +178,9 @@ class GeneralConfig(BaseModel):
         description=desc.GENERAL_SCALE_PREVIEW,
     )
 
-    image_renderer: Literal["icat", "chafa", "imgcat"] = Field(
+    image_renderer: Literal[
+        "icat", "chafa", "imgcat", "system-sixels", "system-kitty", "system-default"
+    ] = Field(
         default_factory=defaults.GENERAL_IMAGE_RENDERER,
         description=desc.GENERAL_IMAGE_RENDERER,
     )