Merged pull request #1 from Anas-Tou/main.

✅Download: Added download support using aria2c (fast) and IDM integration for Windows.
✅MAL Integration: Added 'Relevant' (R) option to fetch currently airing anime via Jikan API with SFW filtering.
✅History: Implemented watch history; watched episodes are now marked with an eye icon.
✅Navigation: Added Next/Previous/Replay menu after watching or downloading.
✅UI: Added 'L' key to jump to the last watched episode in the menu.

Author: np4abdou1

database/history.json

@@ -0,0 +1,7 @@
+{
+    "xOnePiece": {
+        "episode": "1152",
+        "title": "One Piece",
+        "last_updated": "2025-12-23T16:29:53.714824"
+    }
+}

src/api.py

@@ -3,6 +3,7 @@
 import sqlite3
 import base64
 import hashlib
+from datetime import datetime
 from typing import List, Optional, Dict
 from cryptography.fernet import Fernet
 from pathlib import Path
@@ -12,6 +13,57 @@
 # Using it in other projects without permission is prohibited.
 
 class AnimeAPI:
+    def get_mal_season_now(self) -> List[AnimeResult]:
+        """Fetches the currently airing anime from Jikan (MAL Public API)."""
+        url = "https://api.jikan.moe/v4/seasons/now"
+        try:
+            # Jikan API is public and free
+            # params={'sfw': 'true'} filters out 18+ (Rx) content
+            response = requests.get(url, params={'sfw': 'true'}, timeout=10)
+            response.raise_for_status()
+            data = response.json().get('data', [])
+            
+            results = []
+            for item in data:
+                # Extra safety check: Skip if rating contains 'Rx' (Hentai)
+                rating_str = item.get('rating', '')
+                if rating_str and 'Rx' in rating_str:
+                    continue
+
+                # Handle English title fallback
+                title = item.get('title_english') or item.get('title')
+                
+                # Get high-res image if available
+                images = item.get('images', {}).get('jpg', {})
+                thumbnail_url = images.get('large_image_url') or images.get('image_url', '')
+                
+                # Extract genres and studios
+                genres = ", ".join([g['name'] for g in item.get('genres', [])])
+                studios = ", ".join([s['name'] for s in item.get('studios', [])])
+                
+                results.append(AnimeResult(
+                    id="", # EMPTY ID: Signals app.py to search for this title on selection
+                    title_en=title,
+                    title_jp=item.get('title_japanese', ''),
+                    type=item.get('type', 'TV'),
+                    episodes=str(item.get('episodes') or '?'),
+                    status=item.get('status', 'N/A'),
+                    genres=genres,
+                    mal_id=str(item.get('mal_id', '')),
+                    relation_id='',
+                    score=str(item.get('score', 'N/A')),
+                    rank=str(item.get('rank', 'N/A')),
+                    popularity=str(item.get('popularity', 'N/A')),
+                    rating=item.get('rating', 'N/A'),
+                    premiered=f"{item.get('season', '')} {item.get('year', '')}",
+                    creators=studios,
+                    duration=item.get('duration', 'N/A'),
+                    thumbnail=thumbnail_url
+                ))
+            return results
+        except Exception:
+            return []
+
     def search_anime(self, query: str) -> List[AnimeResult]:
         endpoint = ANI_CLI_AR_API_BASE + "anime/load_anime_list_v2.php"
         payload = {
@@ -138,7 +190,6 @@ def _get_db_path(self) -> Path:
 
     def _ensure_db_exists(self):
         if not self.db_path.exists():
-            # Fallback creation logic removed. Database file is now required.
             raise FileNotFoundError(
                 f"Required credentials database not found at: {self.db_path}. "
                 "Please reinstall the application or restore the database file."

src/app.py

@@ -12,13 +12,16 @@
 from .player import PlayerManager
 from .discord_rpc import DiscordRPCManager
 from .models import QualityOption
+from .utils import download_file
+from .history import HistoryManager
 
 class AniCliArApp:
     def __init__(self):
         self.ui = UIManager()
         self.api = AnimeAPI()
         self.rpc = DiscordRPCManager()
         self.player = PlayerManager(rpc_manager=self.rpc, console=self.ui.console)
+        self.history = HistoryManager()
 
     def run(self):
         atexit.register(self.cleanup)
@@ -48,7 +51,7 @@ def main_loop(self):
             self.ui.print()
 
             search_prompt = Panel(
-                Text("Search Anime (or 'q' to quit)", style="info", justify="center"),
+                Text("S Search | R Relevant/Featured (MAL) | Q Quit", style="info", justify="center"),
                 box=HEAVY,
                 padding=(0, 4),
                 border_style=COLOR_BORDER
@@ -67,19 +70,28 @@ def main_loop(self):
             if query.lower() in ['q', 'quit', 'exit']:
                 break
 
-            if not query:
-                continue
-            
-            self.rpc.update_searching()
+            results = []
 
-            results = self.ui.run_with_loading(
-                "Searching anime...",
-                self.api.search_anime,
-                query
-            )
+            if query.lower() == 'r':
+                self.rpc.update_searching()
+                # Fetching from Jikan (MAL) with auto-SFW filtering
+                results = self.ui.run_with_loading(
+                    "Fetching currently airing anime from MAL...",
+                    self.api.get_mal_season_now
+                )
+            elif query.lower() == 's':
+                 term = Prompt.ask(f"{padding} Enter Search Term: ", console=self.ui.console).strip()
+                 if term:
+                    self.rpc.update_searching()
+                    results = self.ui.run_with_loading("Searching...", self.api.search_anime, term)
+            elif query:
+                self.rpc.update_searching()
+                results = self.ui.run_with_loading("Searching...", self.api.search_anime, query)
+            else:
+                continue
 
             if not results:
-                self.ui.render_message("✗ No Results", f"No results found for '{query}'", "error")
+                self.ui.render_message("✗ No Results", f"No results found.", "error")
                 continue
 
             self.handle_anime_selection(results)
@@ -94,6 +106,22 @@ def handle_anime_selection(self, results):
                 return
 
             selected_anime = results[anime_idx]
+
+            # --- BRIDGE LOGIC: MAL to Internal API ---
+            if not selected_anime.id:
+                internal_results = self.ui.run_with_loading(
+                    f"Syncing '{selected_anime.title_en}'...",
+                    self.api.search_anime,
+                    selected_anime.title_en
+                )
+                
+                if not internal_results:
+                     self.ui.render_message("✗ Not Found", f"Sorry, '{selected_anime.title_en}' hasn't been uploaded to the server yet.", "error")
+                     continue
+                
+                selected_anime = internal_results[0]
+            # -----------------------------------------
+
             self.rpc.update_viewing_anime(selected_anime.title_en, selected_anime.thumbnail)
 
             episodes = self.ui.run_with_loading(
@@ -115,33 +143,72 @@ def handle_anime_selection(self, results):
                 break
 
     def handle_episode_selection(self, selected_anime, episodes):
+        current_idx = 0 
+        
         while True:
-            ep_idx = self.ui.episode_selection_menu(selected_anime.title_en, episodes, self.rpc, selected_anime.thumbnail)
+            last_watched = self.history.get_last_watched(selected_anime.id)
+
+            ep_idx = self.ui.episode_selection_menu(
+                selected_anime.title_en, 
+                episodes, 
+                self.rpc, 
+                selected_anime.thumbnail,
+                last_watched_ep=last_watched
+            )
 
             if ep_idx == -1:
                 sys.exit(0)
             elif ep_idx is None:
                 self.rpc.update_browsing()
                 return True
 
-            selected_ep = episodes[ep_idx]
+            current_idx = ep_idx
 
-            server_data = self.ui.run_with_loading(
-                "Loading servers...",
-                self.api.get_streaming_servers,
-                selected_anime.id, 
-                selected_ep.number
-            )
-            
-            if not server_data:
-                self.ui.render_message(
-                    "✗ No Servers", 
-                    "No servers available for this episode.",
-                    "error"
+            while True:
+                selected_ep = episodes[current_idx]
+                
+                server_data = self.ui.run_with_loading(
+                    "Loading servers...",
+                    self.api.get_streaming_servers,
+                    selected_anime.id, 
+                    selected_ep.number
                 )
-                continue
-            
-            self.handle_quality_selection(selected_anime, selected_ep, server_data)
+                
+                if not server_data:
+                    self.ui.render_message(
+                        "✗ No Servers", 
+                        "No servers available for this episode.",
+                        "error"
+                    )
+                    break
+                
+                action_taken = self.handle_quality_selection(selected_anime, selected_ep, server_data)
+                
+                # --- UPDATED LOGIC HERE ---
+                # Check for both "watch" AND "download"
+                if action_taken == "watch" or action_taken == "download":
+                    next_action = self.ui.post_watch_menu()
+                    
+                    if next_action == "Next Episode":
+                        if current_idx + 1 < len(episodes):
+                            current_idx += 1
+                            continue
+                        else:
+                            self.ui.render_message("Info", "No more episodes!", "info")
+                            break
+                    elif next_action == "Previous Episode":
+                        if current_idx > 0:
+                            current_idx -= 1
+                            continue
+                        else:
+                            self.ui.render_message("Info", "This is the first episode.", "info")
+                            break
+                    elif next_action == "Replay":
+                        continue
+                    else:
+                        break
+                else:
+                    break
 
     def handle_quality_selection(self, selected_anime, selected_ep, server_data):
         current_ep_data = server_data.get('CurrentEpisode', {})
@@ -159,21 +226,22 @@ def handle_quality_selection(self, selected_anime, selected_ep, server_data):
                 "No MediaFire servers found for this episode.", 
                 "error"
             )
-            return
+            return None
 
-        idx = self.ui.quality_selection_menu(
+        result = self.ui.quality_selection_menu(
             selected_anime.title_en, 
             selected_ep.display_num, 
             available, 
             self.rpc,
             selected_anime.thumbnail
         )
 
-        if idx == -1:
+        if result == -1:
             sys.exit(0)
-        if idx is None:
-            return
+        if result is None:
+            return None
 
+        idx, action = result
         quality = available[idx]
         server_id = current_ep_data.get(quality.server_key)
 
@@ -184,14 +252,25 @@ def handle_quality_selection(self, selected_anime, selected_ep, server_data):
         )
 
         if direct_url:
-            self.player.play(direct_url, f"{selected_anime.title_en} - Ep {selected_ep.display_num} ({quality.name})")
-            self.rpc.update_selecting_episode(selected_anime.title_en, selected_anime.thumbnail)
+            filename = f"{selected_anime.title_en} - Ep {selected_ep.display_num} [{quality.name.split()[1]}].mp4"
+            
+            if action == 'download':
+                success = download_file(direct_url, filename, self.ui.console)
+                # Save download as "watched" in history so you can jump to it next time
+                self.history.mark_watched(selected_anime.id, selected_ep.display_num, selected_anime.title_en)
+                return "download"
+            else:
+                self.player.play(direct_url, f"{selected_anime.title_en} - Ep {selected_ep.display_num} ({quality.name})")
+                self.history.mark_watched(selected_anime.id, selected_ep.display_num, selected_anime.title_en)
+                self.rpc.update_selecting_episode(selected_anime.title_en, selected_anime.thumbnail)
+                return "watch"
         else:
             self.ui.render_message(
                 "✗ Error", 
                 "Failed to extract direct link from MediaFire.", 
                 "error"
             )
+            return None
 
     def handle_exit(self):
         self.ui.clear()

src/history.py

@@ -0,0 +1,48 @@
+import json
+import os
+from pathlib import Path
+from datetime import datetime
+
+class HistoryManager:
+    def __init__(self):
+        self.history_file = self._get_history_path()
+        self.history = self._load_history()
+
+    def _get_history_path(self) -> Path:
+        # Save in the database directory
+        base_dir = Path(__file__).parent.parent
+        db_dir = base_dir / "database"
+        db_dir.mkdir(exist_ok=True)
+        return db_dir / "history.json"
+
+    def _load_history(self) -> dict:
+        if not self.history_file.exists():
+            return {}
+        try:
+            with open(self.history_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception:
+            return {}
+
+    def save_history(self):
+        try:
+            with open(self.history_file, 'w', encoding='utf-8') as f:
+                json.dump(self.history, f, indent=4, ensure_ascii=False)
+        except Exception:
+            pass
+
+    def mark_watched(self, anime_id, episode_num, anime_title):
+        """Saves the last watched episode for a specific anime."""
+        self.history[str(anime_id)] = {
+            'episode': str(episode_num),
+            'title': anime_title,
+            'last_updated': datetime.now().isoformat()
+        }
+        self.save_history()
+
+    def get_last_watched(self, anime_id):
+        """Returns the episode number of the last watched episode."""
+        data = self.history.get(str(anime_id))
+        if data:
+            return data.get('episode')
+        return None