weebcli 1.0.0

package/src/utils/ui/settings_ui.js

@@ -0,0 +1,322 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import fs from "fs";
+import { getConfig, saveConfig } from "../storage/config.js";
+import { successBox } from "./box.js";
+import { authenticate, verifyToken } from "../anilist.js";
+import { spinner } from "../spinner.js";
+import { commandExists, installPackage } from "../system.js";
+import { sources, getSourcesByLanguage } from "../../sources/index.js";
+import { t, setLanguage } from "../../i18n/index.js";
+
+const pkg = JSON.parse(fs.readFileSync(new URL("./../../../package.json", import.meta.url), "utf-8"));
+
+export async function showSettings() {
+    const config = getConfig();
+    const currentSource = sources.find(s => s.id === config.defaultSource) || sources[0];
+    const currentLang = config.language === "en" ? "English" : "Türkçe";
+
+    console.clear();
+    console.log(chalk.bgCyan.black(` ${t("settings.title")} `) + chalk.gray(` v${pkg.version}`));
+    console.log();
+
+    const { action } = await inquirer.prompt([{
+        type: "list",
+        name: "action",
+        message: t("settings.whatToChange"),
+        pageSize: 15,
+        loop: false,
+        choices: [
+            { name: t("settings.language", { current: chalk.yellow(currentLang) }), value: "language" },
+            { name: t("settings.animeSource", { current: chalk.yellow(currentSource.name) }), value: "defaultSource" },
+            { name: t("settings.player", { current: chalk.yellow(config.defaultPlayer || t("settings.notSelected")) }), value: "defaultPlayer" },
+            { name: t("settings.aria2", { status: chalk.yellow(config.useAria2 ? t("settings.active") : t("settings.inactive")) }), value: "aria2" },
+            ...(config.useAria2 ? [{ name: t("settings.aria2Connections", { count: chalk.yellow(config.aria2Connections) }), value: "aria2Connections" }] : []),
+            { name: t("settings.ytDlp", { status: chalk.yellow(config.useYtDlp !== false ? t("settings.active") : t("settings.inactive")) }), value: "ytDlp" },
+            ...(config.useYtDlp !== false ? [{ name: t("settings.ytDlpConnections", { count: chalk.yellow(config.ytDlpConnections || 16) }), value: "ytDlpConnections" }] : []),
+            { name: t("settings.concurrentLimit", { count: chalk.yellow(config.maxConcurrent) }), value: "maxConcurrent" },
+            { name: t("settings.downloadLocation", { path: chalk.yellow(config.downloadDir) }), value: "downloadDir" },
+            { name: t("settings.retryDownload", { status: chalk.yellow(config.retryEnabled ? t("settings.active") : t("settings.inactive")) }), value: "retryToggle" },
+            ...(config.retryEnabled ? [{ name: t("settings.retrySettings", { count: chalk.yellow(config.retryCount), delay: chalk.yellow(config.retryDelay / 1000) }), value: "retrySettings" }] : []),
+            { name: t("settings.showDetails", { status: chalk.yellow(config.showAnimeDetails !== false ? t("settings.active") : t("settings.inactive")) }), value: "detailsToggle" },
+            { name: t("settings.anilist", { status: chalk.yellow(config.anilistUsername || t("settings.notConnected")) }), value: "anilist" },
+            ...(config.anilistToken ? [{ name: t("settings.anilistLogout"), value: "anilistLogout" }] : []),
+            new inquirer.Separator(),
+            { name: t("settings.backToMenu"), value: "back" }
+        ]
+    }]);
+
+    if (action === "back") return;
+
+    if (action === "language") {
+        const { lang } = await inquirer.prompt([{
+            type: "list",
+            name: "lang",
+            message: t("settings.selectLanguage"),
+            choices: [
+                { name: t("settings.turkish"), value: "tr" },
+                { name: t("settings.english"), value: "en" }
+            ],
+            default: config.language || "tr"
+        }]);
+
+        config.language = lang;
+        setLanguage(lang);
+        
+        const availableSources = getSourcesByLanguage(lang);
+        const currentSourceValid = availableSources.some(s => s.id === config.defaultSource);
+        if (!currentSourceValid && availableSources.length > 0) {
+            config.defaultSource = availableSources[0].id;
+        }
+        
+        saveConfig(config);
+        successBox(t("settings.languageUpdated"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await showSettings();
+        return;
+    }
+
+    if (action === "defaultSource") {
+        const currentLangCode = config.language || "tr";
+        const availableSources = getSourcesByLanguage(currentLangCode);
+
+        const { source } = await inquirer.prompt([{
+            type: "list",
+            name: "source",
+            message: t("settings.selectSource"),
+            choices: availableSources.map(s => ({
+                name: `${s.name}${s.supportsLocalSearch ? chalk.gray(` (${t("settings.advancedSearch")})`) : ""}`,
+                value: s.id
+            })),
+            default: config.defaultSource || availableSources[0]?.id
+        }]);
+
+        config.defaultSource = source;
+        saveConfig(config);
+        successBox(t("settings.sourceUpdated"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await showSettings();
+        return;
+    }
+
+    if (action === "detailsToggle") {
+        config.showAnimeDetails = config.showAnimeDetails === false ? true : false;
+        saveConfig(config);
+        successBox(config.showAnimeDetails ? t("settings.detailsEnabled") : t("settings.detailsDisabled"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await showSettings();
+        return;
+    }
+
+
+    if (action === "anilistLogout") {
+        const { confirm } = await inquirer.prompt([{
+            type: "confirm",
+            name: "confirm",
+            message: t("settings.anilistDisconnectConfirm"),
+            default: false
+        }]);
+
+        if (confirm) {
+            config.anilistToken = undefined;
+            config.anilistUsername = undefined;
+            saveConfig(config);
+            console.log(chalk.yellow("\n" + t("settings.anilistDisconnected")));
+        } else {
+            console.log(chalk.gray(t("settings.operationCancelled")));
+        }
+
+        await new Promise(resolve => setTimeout(resolve, 1500));
+        await showSettings();
+        return;
+    }
+
+    if (action === "anilist") {
+        if (config.anilistToken) {
+            await showSettings();
+            return;
+        }
+
+        try {
+            const token = await authenticate();
+            spinner.start(t("anilist.verifying"));
+            const username = await verifyToken(token);
+            spinner.stop();
+
+            if (username) {
+                config.anilistToken = token;
+                config.anilistUsername = username;
+                console.log(chalk.green(`\n${t("anilist.loginSuccess", { username })}`));
+            } else {
+                console.log(chalk.red("\n" + t("anilist.verifyFailed")));
+            }
+        } catch (error) {
+            console.log(chalk.red("\n" + t("anilist.loginFailed", { message: error.message })));
+        }
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        saveConfig(config);
+        await showSettings();
+        return;
+    }
+
+
+    if (action === "defaultPlayer") {
+        const { player } = await inquirer.prompt([{
+            type: "list",
+            name: "player",
+            message: t("settings.selectPlayer"),
+            choices: [
+                { name: t("setup.mpvWithResume"), value: "mpv" },
+                { name: t("setup.vlcPlayer"), value: "vlc" }
+            ],
+            default: config.defaultPlayer || "mpv"
+        }]);
+
+        if (!commandExists(player)) {
+            console.log(chalk.yellow(`\n${t("settings.playerNotFound", { player })}`));
+            const { install } = await inquirer.prompt([{
+                type: "confirm",
+                name: "install",
+                message: t("settings.autoInstallPrompt"),
+                default: true
+            }]);
+
+            if (install) {
+                console.log(chalk.yellow(t("settings.installingPlayer")));
+                const success = installPackage(player);
+                if (success) {
+                    console.log(chalk.green(`\n${t("settings.playerInstalled", { player })}`));
+                } else {
+                    console.log(chalk.red("\n" + t("settings.installFailed")));
+                }
+            }
+        }
+
+        config.defaultPlayer = player;
+        saveConfig(config);
+        successBox(t("settings.playerUpdated"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await showSettings();
+        return;
+    }
+
+    if (action === "maxConcurrent") {
+        const { limit } = await inquirer.prompt([{
+            type: "number",
+            name: "limit",
+            message: t("settings.concurrentPrompt"),
+            default: config.maxConcurrent,
+            validate: (input) => (input > 0 && input <= 10) ? true : t("settings.concurrentValidation")
+        }]);
+        config.maxConcurrent = limit;
+        saveConfig(config);
+        successBox(t("settings.concurrentUpdated"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await showSettings();
+        return;
+    }
+
+    if (action === "aria2") {
+        config.useAria2 = !config.useAria2;
+        saveConfig(config);
+        successBox(config.useAria2 ? t("settings.aria2Enabled") : t("settings.aria2Disabled"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await showSettings();
+        return;
+    }
+
+    if (action === "aria2Connections") {
+        const { connections } = await inquirer.prompt([{
+            type: "number",
+            name: "connections",
+            message: t("settings.aria2ConnectionsPrompt"),
+            default: config.aria2Connections || 16,
+            validate: (input) => (input > 0 && input <= 32) ? true : t("settings.aria2ConnectionsValidation")
+        }]);
+        config.aria2Connections = connections;
+        saveConfig(config);
+        successBox(t("settings.aria2ConnectionsUpdated"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await showSettings();
+        return;
+    }
+
+    if (action === "ytDlp") {
+        config.useYtDlp = config.useYtDlp === false ? true : false;
+        saveConfig(config);
+        successBox(config.useYtDlp ? t("settings.ytDlpEnabled") : t("settings.ytDlpDisabled"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await showSettings();
+        return;
+    }
+
+    if (action === "ytDlpConnections") {
+        const { connections } = await inquirer.prompt([{
+            type: "number",
+            name: "connections",
+            message: t("settings.ytDlpConnectionsPrompt"),
+            default: config.ytDlpConnections || 16,
+            validate: (input) => (input > 0 && input <= 32) ? true : t("settings.ytDlpConnectionsValidation")
+        }]);
+        config.ytDlpConnections = connections;
+        saveConfig(config);
+        successBox(t("settings.ytDlpConnectionsUpdated"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await showSettings();
+        return;
+    }
+
+
+    if (action === "downloadDir") {
+        const { dir } = await inquirer.prompt([{
+            type: "input",
+            name: "dir",
+            message: t("settings.downloadDirPrompt"),
+            default: config.downloadDir,
+            validate: (input) => input.trim() !== "" ? true : t("settings.downloadDirValidation")
+        }]);
+        config.downloadDir = dir;
+        saveConfig(config);
+        successBox(t("settings.downloadDirUpdated"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await showSettings();
+        return;
+    }
+
+    if (action === "retryToggle") {
+        config.retryEnabled = !config.retryEnabled;
+        successBox(config.retryEnabled ? t("settings.retryEnabled") : t("settings.retryDisabled"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        saveConfig(config);
+        await showSettings();
+        return;
+    }
+
+    if (action === "retrySettings") {
+        const { count, delay } = await inquirer.prompt([
+            {
+                type: "number",
+                name: "count",
+                message: t("settings.retryCountPrompt"),
+                default: config.retryCount,
+                validate: (input) => (input >= 0 && input <= 10) ? true : t("settings.retryCountValidation")
+            },
+            {
+                type: "number",
+                name: "delay",
+                message: t("settings.retryDelayPrompt"),
+                default: config.retryDelay / 1000,
+                validate: (input) => (input >= 0) ? true : t("settings.retryDelayValidation")
+            }
+        ]);
+
+        config.retryCount = count;
+        config.retryDelay = delay * 1000;
+
+        saveConfig(config);
+        successBox(t("settings.retryUpdated"));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await showSettings();
+        return;
+    }
+}

package/src/utils/ui/show_history.js

@@ -0,0 +1,92 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { loadHistory } from "../storage/history.js";
+import { stats } from "./stats.js";
+import { t } from "../../i18n/index.js";
+
+export async function showHistory() {
+    const history = loadHistory();
+    const items = Object.values(history);
+
+    const completed = items.filter(i => i.completed);
+    const inProgress = items.filter(i => !i.completed);
+
+    console.clear();
+    console.log(chalk.bgMagenta.black(` ${t("history.title")} `));
+    console.log("");
+
+    const { type } = await inquirer.prompt([{
+        type: "list",
+        name: "type",
+        message: t("history.selectList"),
+        loop: false,
+        choices: [
+            { name: t("history.statistics"), value: "stats" },
+            { name: t("history.inProgress", { count: inProgress.length }), value: "progress" },
+            { name: t("history.completed", { count: completed.length }), value: "completed" },
+            new inquirer.Separator(),
+            { name: t("history.goBack"), value: "back" }
+        ]
+    }]);
+
+    if (type === "back") return;
+
+    if (type === "stats") {
+        await stats();
+        await showHistory();
+        return;
+    }
+
+    if (type === "completed") {
+        console.clear();
+        console.log(chalk.bgGreen.black(` ${t("history.completedTitle")} `));
+        console.log("");
+
+        if (completed.length === 0) {
+            console.log(chalk.yellow("  " + t("history.noCompleted")));
+        } else {
+            completed.forEach(anime => {
+                console.log(`  ${chalk.cyan("●")} ${chalk.white(anime.name)} ${chalk.gray(`- ${new Date(anime.lastWatchedAt).toLocaleDateString()}`)}`);
+            });
+        }
+        console.log("");
+
+        await inquirer.prompt([{ type: "input", name: "dummy", message: t("history.pressEnter") }]);
+        await showHistory();
+    } else if (type === "progress") {
+        if (inProgress.length === 0) {
+            console.log(chalk.yellow("\n" + t("history.noWatching")));
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            await showHistory();
+            return;
+        }
+
+        const { anime } = await inquirer.prompt([{
+            type: "list",
+            name: "anime",
+            message: t("history.selectForDetails"),
+            loop: false,
+            choices: [
+                ...inProgress.map(i => ({
+                    name: `${i.name} ${chalk.gray(`(${t("history.lastEpisode", { episode: i.lastEpisode })})`)}`,
+                    value: i
+                })),
+                new inquirer.Separator(),
+                { name: t("history.goBack"), value: "back" }
+            ]
+        }]);
+
+        if (anime === "back") {
+            await showHistory();
+            return;
+        }
+
+        console.log(chalk.cyan(`\n${anime.name}`));
+        console.log(chalk.gray(t("history.lastEpisodeLabel", { episode: anime.lastEpisode })));
+        console.log(chalk.gray(t("history.totalEpisodes", { count: anime.totalEpisodes })));
+        console.log(chalk.gray(t("history.lastWatchedDate", { date: new Date(anime.lastWatchedAt).toLocaleString() })));
+
+        await inquirer.prompt([{ type: "input", name: "dummy", message: t("history.pressEnter") }]);
+        await showHistory();
+    }
+}

package/src/utils/ui/stats.js

@@ -0,0 +1,67 @@
+// @ts-check
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { loadHistory } from "../storage/history.js";
+import { t } from "../../i18n/index.js";
+
+export async function stats() {
+    console.clear();
+    const history = loadHistory();
+    const animes = Object.values(history);
+
+    if (animes.length === 0) {
+        console.log(chalk.yellow(t("stats.emptyHistory")));
+        await inquirer.prompt([{ type: 'input', name: 'devam', message: t("stats.pressEnter") }]);
+        return;
+    }
+
+    const totalAnimes = animes.length;
+    const completedAnimes = animes.filter(a => a.completed).length;
+    const watchingAnimes = totalAnimes - completedAnimes;
+
+    const totalEpisodes = animes.reduce((acc, curr) => acc + (curr.lastEpisode || 0), 0);
+
+    const totalMinutes = totalEpisodes * 24;
+    const hours = Math.floor(totalMinutes / 60);
+    const days = (hours / 24).toFixed(1);
+
+    const lastWatched = animes.sort((a, b) => new Date(b.lastWatchedAt).getTime() - new Date(a.lastWatchedAt).getTime())[0];
+
+    console.log(`${chalk.cyan(t("stats.totalAnime"))}    ${chalk.bold(totalAnimes)}`);
+    console.log(`${chalk.cyan(t("stats.completedAnime"))}   ${chalk.green(completedAnimes)}`);
+    console.log(`${chalk.cyan(t("stats.watchingAnime"))}   ${chalk.yellow(watchingAnimes)}`);
+    console.log("");
+    console.log(`${chalk.cyan(t("stats.totalEpisodes"))}    ${chalk.bold(totalEpisodes)}`);
+    console.log(`${chalk.cyan(t("stats.watchTime"))}   ${chalk.bold(t("stats.hours", { hours }))} ${chalk.gray(`(${t("stats.days", { days })})`)}`);
+    console.log("");
+
+    if (lastWatched) {
+        console.log(`${chalk.cyan(t("stats.lastWatched"))}     ${chalk.magenta(lastWatched.name)} ${chalk.gray(`(${timeAgo(new Date(lastWatched.lastWatchedAt))})`)}`);
+    }
+
+    await inquirer.prompt([{ type: 'input', name: 'devam', message: t("stats.pressEnter") }]);
+}
+
+/**
+ * @param {Date} date
+ */
+function timeAgo(date) {
+    const seconds = Math.floor((new Date().getTime() - date.getTime()) / 1000);
+
+    let interval = seconds / 31536000;
+    if (interval > 1) return t("stats.timeAgo.years", { count: Math.floor(interval) });
+
+    interval = seconds / 2592000;
+    if (interval > 1) return t("stats.timeAgo.months", { count: Math.floor(interval) });
+
+    interval = seconds / 86400;
+    if (interval > 1) return t("stats.timeAgo.days", { count: Math.floor(interval) });
+
+    interval = seconds / 3600;
+    if (interval > 1) return t("stats.timeAgo.hours", { count: Math.floor(interval) });
+
+    interval = seconds / 60;
+    if (interval > 1) return t("stats.timeAgo.minutes", { count: Math.floor(interval) });
+
+    return t("stats.timeAgo.justNow");
+}

package/start.js

@@ -0,0 +1,21 @@
+// @ts-check
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+
+if (!fs.existsSync(path.join(process.cwd(), "node_modules"))) {
+	console.log("gerekli moduller eksik, yukleniyor...");
+	try {
+		execSync("npm install", { stdio: "inherit" });
+		console.log("moduller basariyla yuklendi.");
+	} catch (error) {
+		console.error("modul yukleme hatasi:", error.message);
+		process.exit(1);
+	}
+}
+
+try {
+	import("./src/index.js");
+} catch (error) {
+	console.error("uygulama baslatilamadi:", error);
+}

package/tanitim-en.md

@@ -0,0 +1,66 @@
+I'm sure many of us have spent hours on torrent sites trying to download anime, dealing with low-quality links or slow downloads.
+
+Now I want to introduce you to an amazing tool that lets you easily watch and download anime on **computer, tablet and phone**,
+
+**Animely**:
+
+**Animely** is a CLI tool developed with Node.js. It allows you to both watch and download anime from popular platforms like AnimeElysium (animely.net), Animecix (animecix.tv) and AllAnime.
+
+* **Key features that set Animely apart from other tools:**
+* **Multiple Source Support**: Turkish (AnimeElysium, Animecix) and English (AllAnime) sources
+* **Multi-Language Support**: Turkish and English interface, automatic source filtering based on selected language
+* **Sub/Dub Option**: Subbed or dubbed viewing option on AllAnime
+* **Instant Streaming**: Start watching with VLC or MPV without waiting for downloads
+* **Resume Playback**: No need to remember where you left off, it automatically saves which episode and minute you stopped at
+* **Quality Selection**: Options like 480p, 720p, 1080p (for Animecix and AllAnime)
+* **Anilist Integration**: Automatically add watched episodes to your Anilist profile
+* **Discord Rich Presence**: Show the anime you're watching live on Discord
+* **Smart Downloads**: Queue system, concurrent downloads, resume capability and more
+* **Aria2 Support**: Ultra-fast downloads with 16 connections for MP4 files
+* **yt-dlp Support**: Fast downloads with parallel connections for M3U8/HLS streams
+
+**Just follow these steps to install this amazing tool:**
+**[Hey! First of all, you need to install Node.js!](https://nodejs.org/en/download)**
+
+	
+	**Installation with NPM (All platforms):**
+	```bash
+	npm install -g animely
+	``` 
+
+	**Installation with AUR (Arch Linux based distros):**
+
+	```bash
+	yay -S animely
+	``` 
+        or,
+	```bash
+	paru -S animely
+	``` 
+
+        After installation,
+	```bash
+	animely
+	```
+
+**Done? Not yet! There's also an easy-to-use web version for mobile devices or those who don't want to deal with installation!**:
+**[animely.ewgsta.me](https://animely.ewgsta.me)** just log in with your Discord account after entering the site.
+
+
+**Screenshots & Links:**
+
+*Github:* **[Remember this project was developed completely open source, it's very important to show your love and support by leaving a star on the github repo.. :)](https://github.com/ewgsta/animely)**
+
+***Enjoy!***
+
+CLI
+
+https://r2.fakecrime.bio/uploads/10b1f77e-f967-45bf-9a74-e4c539c52dfe.png 
+https://r2.fakecrime.bio/uploads/6a01a11a-309c-4d3a-8d40-04ed81e4476b.png
+https://r2.fakecrime.bio/uploads/95ff108b-dc25-44a2-a51a-1457b35ce99c.png
+https://r2.fakecrime.bio/uploads/4f92ad64-056e-4661-bc3a-d7e9def1793f.png
+
+Web
+
+https://r2.fakecrime.bio/uploads/fe9a4785-77da-4203-ad22-74cb6b171aec.png
+https://r2.fakecrime.bio/uploads/97391eca-3ab0-483d-86e6-0d199be45bde.png

package/tanitim-tr.md

@@ -0,0 +1,66 @@
+Eminim ki birçoğumuz uzun yıllardır anime indirebilmek için torrent sitelerinde saatler harcadık, kalitesiz linklerle veya yavaş indirmelerle uğraştık.
+
+Artık **bilgisayar, tablet ve telefon** fark etmeksizin kolayca anime izleyip indirebileceğiniz harika bir aracı tanıtmak istiyorum,
+
+**Animely**:
+
+**Animely**, Node.js ile geliştirilmiş bir CLI aracıdır. AnimeElysium (animely.net), Animecix (animecix.tv) ve AllAnime gibi popüler platformlar üzerinden animeleri hem izlemenize hem de indirmenize olanak tanır.
+
+* **Animely'yi diğer araçlardan ayıran başlıca özellikler:**
+* **Çoklu Kaynak Desteği**: Türkçe (AnimeElysium, Animecix) ve İngilizce (AllAnime) kaynaklar
+* **Çoklu Dil Desteği**: Türkçe ve İngilizce arayüz, seçtiğiniz dile göre otomatik kaynak filtreleme
+* **Sub/Dub Seçeneği**: AllAnime'de altyazılı veya dublajlı izleme imkanı
+* **Anında İzleme**: VLC veya MPV ile indirmeyi beklemeden izlemeye başlayın
+* **Kaldığı Yerden Devam**: Kaldığınız yeri hatırlamak zorunda değilsiniz hangi bölüm hangi dakikada kaldığını otomatik olarak kaydeder
+* **Kalite Seçimi**: 480p, 720p, 1080p gibi seçenekler (Animecix ve AllAnime için)
+* **Anilist Entegrasyonu**: İzlenen bölümleri otomatik Anilist profilinize ekleyin
+* **Discord Rich Presence**: İzlediğiniz animeyi discord'da canlı olarak gösterin 
+* **Akıllı İndirme**: Kuyruk sistemi, eşzamanlı indirme ve kaldığı yerden devam etme ve dahası
+* **Aria2 Desteği**: MP4 dosyaları için 16 bağlantı ile ultra hızlı indirme
+* **yt-dlp Desteği**: M3U8/HLS stream'leri için paralel bağlantı ile hızlı indirme
+
+**Bu mükemmel aracı kurabilmek için aşağıdaki adımları izlemen yeterli:**
+**[Hey! Her şeyden önce Node.js kurmalısın!](https://nodejs.org/tr/download)**
+
+	
+	**NPM ile Kurulum (Tüm platformlar):**
+	```bash
+	npm install -g animely
+	``` 
+
+	**AUR ile Kurulum (Arch Linux tabanlı dağıtımlar):**
+
+	```bash
+	yay -S animely
+	``` 
+        veya,
+	```bash
+	paru -S animely
+	``` 
+
+        Kurulumdan sonra,
+	```bash
+	animely
+	```
+
+**Bitti mi? Bitmedi! Mobil cihazlar veya kurulumla uğraşmak istemeyenler için kullanımı kolay web versiyonu da mevcut!**:
+**[animely.ewgsta.me](https://animely.ewgsta.me)** siteye girdikten sonra discord hesabınız ile giriş yapmanız yeterli.
+
+
+**Görseller & Bağlantılar:**
+
+*Github:* **[Unutmayın bu proje tamamen açık kaynaklı bir şekilde geliştirildi, github deposuna star bırakarak projeyi sevdiğinizi ve desteklediğinizi göstermeniz çok önemli.. :)](https://github.com/ewgsta/animely)**
+
+***İyi eğlenceler!***
+
+CLI
+
+https://r2.fakecrime.bio/uploads/10b1f77e-f967-45bf-9a74-e4c539c52dfe.png 
+https://r2.fakecrime.bio/uploads/6a01a11a-309c-4d3a-8d40-04ed81e4476b.png
+https://r2.fakecrime.bio/uploads/95ff108b-dc25-44a2-a51a-1457b35ce99c.png
+https://r2.fakecrime.bio/uploads/4f92ad64-056e-4661-bc3a-d7e9def1793f.png
+
+Web
+
+https://r2.fakecrime.bio/uploads/fe9a4785-77da-4203-ad22-74cb6b171aec.png
+https://r2.fakecrime.bio/uploads/97391eca-3ab0-483d-86e6-0d199be45bde.png