ani-auto 1.0.1 → 1.0.4

package/README.md

@@ -23,20 +23,28 @@ ani-auto check
 
 ## commands
 
-| command | description |
-|---|---|
-| `setup` | first-time setup wizard |
-| `check` | download new episodes (interactive) |
-| `check --auto` | download everything, no prompts |
-| `list` | show tracked anime |
-| `add "<title>"` | add anime to manual list |
-| `remove` | remove from manual list |
-| `enable` | re-enable a paused anime |
-| `disable` | pause downloads for an anime |
-| `status` | view recent download history |
-| `config` | view or update settings |
-| `config --open` | open config file in editor |
-| `daemon` | start background auto-downloader |
+```
+Usage: ani-auto [options] [command]
+
+Automatic anime episode downloader — AniList-aware
+
+Options:
+  -V, --version          output the version number
+  -h, --help             display help for command
+
+Commands:
+  setup                  Interactive first-time configuration wizard
+  check [options]        Run one download cycle immediately
+  list                   Show all tracked anime and their episode download status
+  add [options] <title>  Search AniList and add an anime to the manual download list
+  remove [title]         Remove an anime from the manual list (interactive if no title given)
+  enable                 Re-enable downloads for an anime
+  disable                Pause downloads for an anime (keeps history)
+  status [options]       Show recent run log
+  config [options]       View, update, or open config file
+  daemon [options]       Start the background daemon
+  help [command]         display help for command
+```
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ani-auto",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "Automatic anime episode downloader",
   "bin": {
     "ani-auto": "./src/cli.js"

package/src/cli.js

@@ -1,22 +1,6 @@
 #!/usr/bin/env node
 'use strict';
 
-/**
- * cli.js  —  ani-auto command line interface
- *
- * Commands:
- *   setup              Interactive first-time setup wizard
- *   check              Run one download cycle immediately
- *   list               Show all tracked anime
- *   add  <title>       Add anime to manual list
- *   remove <title>     Remove anime from manual list
- *   enable  <title>    Re-enable a disabled entry
- *   disable <title>    Pause downloads for an anime
- *   status             Show recent run log + per-anime episode counts
- *   config             View / edit config values
- *   daemon             Start the background daemon
- */
-
 const { program } = require('commander');
 const inquirer    = require('inquirer');
 const chalk       = require('chalk');
@@ -28,10 +12,8 @@ const { runCycle } = require('./engine');
 const { getViewer } = require('./anilist');
 const { version } = require('../package.json');
 
-// ── Banner ────────────────────────────────────────────────────────────────
-
 function banner() {
-       console.log(chalk.bold.red(`
+    console.log(chalk.bold.red(`
       █████╗ ███╗   ██╗██╗      █████╗ ██╗   ██╗████████╗ ██████╗ 
      ██╔══██╗████╗  ██║██║     ██╔══██╗██║   ██║╚══██╔══╝██╔═══██╗
      ███████║██╔██╗ ██║██║     ███████║██║   ██║   ██║   ██║   ██║
@@ -40,8 +22,7 @@ function banner() {
      ╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝     ╚═╝  ╚═╝ ╚═════╝    ╚═╝    ╚═════╝ 
             A N I M E   A U T O   D O W N L O A D E R
        `));
-       }
-// ── setup ─────────────────────────────────────────────────────────────────
+}
 
 program
     .command('setup')
@@ -49,27 +30,21 @@ program
     .action(async () => {
         banner();
         const current = loadConfig();
-
         console.log(chalk.cyan('  Let\'s configure your auto-downloader.\n'));
 
-        // Step 1: get username
         const { anilistUsername } = await inquirer.prompt([{
-            type:    'input',
-            name:    'anilistUsername',
+            type: 'input', name: 'anilistUsername',
             message: 'AniList username (leave blank to skip AniList integration):',
             default: current.anilistUsername || '',
         }]);
 
-        // Step 2: if username given, open browser THEN ask for token
         let anilistToken = current.anilistToken || '';
         let watchStatuses = current.watchStatuses || ['CURRENT'];
 
         if (anilistUsername) {
             const { openBrowser } = await inquirer.prompt([{
-                type:    'confirm',
-                name:    'openBrowser',
-                message: 'Open browser to get AniList token?',
-                default: true,
+                type: 'confirm', name: 'openBrowser',
+                message: 'Open browser to get AniList token?', default: true,
             }]);
 
             if (openBrowser) {
@@ -80,11 +55,7 @@ program
                               : ['xdg-open', 'firefox'];
                 let opened = false;
                 for (const opener of openers) {
-                    try {
-                        spawn(opener, [url], { stdio: 'ignore', detached: true, env: process.env }).unref();
-                        opened = true;
-                        break;
-                    } catch (e) {}
+                    try { spawn(opener, [url], { stdio: 'ignore', detached: true, env: process.env }).unref(); opened = true; break; } catch (e) {}
                 }
                 console.log(chalk.cyan(`\n  ${opened ? 'Browser opened!' : 'Visit:'} ${url}`));
                 console.log(chalk.gray('  Authorize, then copy the token from the URL (the part after access_token=).\n'));
@@ -92,16 +63,13 @@ program
             }
 
             const tokenAnswer = await inquirer.prompt([{
-                type:    'password',
-                name:    'anilistToken',
-                message: 'Paste your AniList token here:',
-                default: current.anilistToken || '',
+                type: 'password', name: 'anilistToken',
+                message: 'Paste your AniList token here:', default: current.anilistToken || '',
             }]);
             anilistToken = tokenAnswer.anilistToken;
 
             const statusAnswer = await inquirer.prompt([{
-                type:    'list',
-                name:    'watchStatuses',
+                type: 'list', name: 'watchStatuses',
                 message: 'Which AniList status to download?',
                 choices: [
                     { name: 'CURRENT   (Watching)',      value: 'CURRENT' },
@@ -110,70 +78,36 @@ program
                     { name: 'REPEATING',                 value: 'REPEATING' },
                 ],
                 default: (current.watchStatuses || ['CURRENT'])[0],
-                filter:  v => [v],
+                filter: v => [v],
             }]);
             watchStatuses = statusAnswer.watchStatuses;
         }
 
-        // Step 3: rest of config
         const answers = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'quality',
-                message: 'Default download quality:',
-                choices: ['1080p', '720p', '480p', '360p'],
-                default: current.quality || '1080p',
-            },
-            {
-                type: 'list',
-                name: 'language',
-                message: 'Default audio language:',
-                choices: ['sub', 'dub'],
-                default: current.language || 'sub',
-            },
-            {
-                type: 'number',
-                name: 'concurrency',
-                message: 'Parallel downloads per run (1-10):',
-                default: current.concurrency || 2,
-                validate: v => (v >= 1 && v <= 10) ? true : 'Enter a number 1–10',
-            },
-            {
-                type: 'input',
-                name: 'outputDir',
-                message: 'Output directory for downloads:',
-                default: current.outputDir,
-            },
-            {
-                type: 'number',
-                name: 'daemonIntervalMinutes',
-                message: 'Daemon polling interval (minutes):',
-                default: current.daemonIntervalMinutes || 30,
-            },
+            { type: 'list',   name: 'quality',               message: 'Default download quality:', choices: ['1080p', '720p', '480p', '360p'], default: current.quality || '1080p' },
+            { type: 'list',   name: 'language',              message: 'Default audio language:',   choices: ['sub', 'dub'], default: current.language || 'sub' },
+            { type: 'number', name: 'concurrency',           message: 'Parallel downloads per run (1-10):', default: current.concurrency || 2, validate: v => (v >= 1 && v <= 10) ? true : 'Enter a number 1–10' },
+            { type: 'input',  name: 'outputDir',             message: 'Output directory for downloads:', default: current.outputDir },
+            { type: 'number', name: 'daemonIntervalMinutes', message: 'Daemon polling interval (minutes):', default: current.daemonIntervalMinutes || 30 },
         ]);
         answers.anilistUsername = anilistUsername;
         answers.anilistToken    = anilistToken;
         answers.watchStatuses   = watchStatuses;
 
-        // Verify AniList token if provided
         if (answers.anilistToken) {
             const spinner = ora('Verifying AniList token...').start();
-            try {
-                const viewer = await getViewer(answers.anilistToken);
-                spinner.succeed(`Logged in as ${chalk.bold(viewer.name)}`);
-            } catch {
-                spinner.warn('Could not verify token — saved anyway, check it manually.');
-            }
+            try { const viewer = await getViewer(answers.anilistToken); spinner.succeed(`Logged in as ${chalk.bold(viewer.name)}`); }
+            catch { spinner.warn('Could not verify token — saved anyway, check it manually.'); }
         }
 
         updateConfig({
-            anilistUsername:       answers.anilistUsername || null,
-            anilistToken:          answers.anilistToken    || null,
-            watchStatuses:         answers.watchStatuses   || current.watchStatuses,
-            quality:               answers.quality,
-            language:              answers.language,
-            concurrency:           answers.concurrency,
-            outputDir:             answers.outputDir,
+            anilistUsername: answers.anilistUsername || null,
+            anilistToken:    answers.anilistToken    || null,
+            watchStatuses:   answers.watchStatuses   || current.watchStatuses,
+            quality:         answers.quality,
+            language:        answers.language,
+            concurrency:     answers.concurrency,
+            outputDir:       answers.outputDir,
             daemonIntervalMinutes: answers.daemonIntervalMinutes,
         });
 
@@ -182,8 +116,6 @@ program
         console.log(`  Run ${chalk.bold('ani-auto daemon')} to start the background daemon.\n`);
     });
 
-// ── check ─────────────────────────────────────────────────────────────────
-
 program
     .command('check')
     .description('Run one download cycle immediately')
@@ -191,15 +123,38 @@ program
     .action(async (opts) => {
         banner();
         try {
-            await runCycle({ auto: !!opts.auto });
-        } catch (e) {
-            console.error(chalk.red('[ERROR]'), e.message);
-            process.exit(1);
+            const config = loadConfig();
+            let quality  = config.quality  || '1080p';
+            let language = config.language || 'sub';
+
+            if (!opts.auto) {
+                const { pickedQuality, saveAsDefault } = await inquirer.prompt([
+                    {
+                        type:    'list',
+                        name:    'pickedQuality',
+                        message: 'Quality for this run:',
+                        choices: ['1080p', '720p', '480p', '360p'],
+                        default: quality,
+                    },
+                    {
+                        type:    'confirm',
+                        name:    'saveAsDefault',
+                        message: 'Save as default quality?',
+                        default: false,
+                    },
+                ]);
+                quality = pickedQuality;
+                if (saveAsDefault) {
+                    updateConfig({ quality });
+                    console.log(chalk.green(`  ✔  Saved default quality: ${quality}\n`));
+                }
+            }
+
+            await runCycle({ auto: !!opts.auto, quality, language });
         }
+        catch (e) { console.error(chalk.red('[ERROR]'), e.message); process.exit(1); }
     });
 
-// ── list ──────────────────────────────────────────────────────────────────
-
 program
     .command('list')
     .description('Show all tracked anime and their episode download status')
@@ -220,21 +175,15 @@ program
 
         console.log(chalk.bold(`  ${'Title'.padEnd(40)} ${'Source'.padEnd(8)} ${'Enabled'.padEnd(8)} Done  Failed`));
         console.log('  ' + '─'.repeat(72));
-
         for (const row of all) {
             const stats   = db.getEpisodeStats(row.id);
             const enabled = row.enabled ? chalk.green('yes') : chalk.gray('no');
             const title   = row.title.length > 38 ? row.title.slice(0, 37) + '…' : row.title;
-            console.log(
-                `  ${title.padEnd(40)} ${row.source.padEnd(8)} ${enabled.padEnd(16)} ` +
-                `${chalk.green(String(stats.done).padEnd(6))}${chalk.red(stats.failed)}`
-            );
+            console.log(`  ${title.padEnd(40)} ${row.source.padEnd(8)} ${enabled.padEnd(16)} ${chalk.green(String(stats.done).padEnd(6))}${chalk.red(stats.failed)}`);
         }
         console.log('');
     });
 
-// ── add ───────────────────────────────────────────────────────────────────
-
 program
     .command('add <title>')
     .description('Search AniList and add an anime to the manual download list')
@@ -243,30 +192,17 @@ program
     .action(async (title, opts) => {
         banner();
         await db.initDb();
-
         const { searchAnime, pickTitle } = require('./anilist');
-        const ora = require('ora');
 
         const spinner = ora(`Searching AniList for "${title}"...`).start();
         let results;
-        try {
-            results = await searchAnime(title);
-            spinner.stop();
-        } catch (e) {
-            spinner.fail(`AniList search failed: ${e.message}`);
-            return;
-        }
+        try { results = await searchAnime(title); spinner.stop(); }
+        catch (e) { spinner.fail(`AniList search failed: ${e.message}`); return; }
 
-        if (!results.length) {
-            console.log(chalk.yellow(`  No results found on AniList for ${title}.`));
-            return;
-        }
+        if (!results.length) { console.log(chalk.yellow(`  No results found on AniList for ${title}.`)); return; }
 
-        // Let user pick the right match
         const { picked } = await inquirer.prompt([{
-            type:    'list',
-            name:    'picked',
-            message: 'Select the anime:',
+            type: 'list', name: 'picked', message: 'Select the anime:',
             choices: results.map(r => ({
                 name:  `${pickTitle(r.titles)} (${r.year || '?'}) — ${r.episodes ? r.episodes + ' eps' : 'ongoing'} [${r.status}]`,
                 value: r,
@@ -278,19 +214,9 @@ program
         const manualList = config.manualList || [];
 
         const exists = manualList.find(m => m.title.toLowerCase() === resolvedTitle.toLowerCase());
-        if (exists) {
-            console.log(chalk.yellow(`  ${resolvedTitle} is already in your manual list.`));
-            return;
-        }
-
-        const entry = {
-            title:     resolvedTitle,
-            anilistId: picked.anilistId,
-            enabled:   true,
-            quality:   opts.quality  || null,
-            language:  opts.language || null,
-        };
+        if (exists) { console.log(chalk.yellow(`  ${resolvedTitle} is already in your manual list.`)); return; }
 
+        const entry = { title: resolvedTitle, anilistId: picked.anilistId, enabled: true, quality: opts.quality || null, language: opts.language || null };
         manualList.push(entry);
         updateConfig({ manualList });
         db.upsertAnime({ title: resolvedTitle, siteId: resolvedTitle, anilistId: picked.anilistId, source: 'manual', quality: entry.quality, language: entry.language });
@@ -301,8 +227,6 @@ program
         console.log('');
     });
 
-// ── remove ────────────────────────────────────────────────────────────────
-
 program
     .command('remove [title]')
     .description('Remove an anime from the manual list (interactive if no title given)')
@@ -312,39 +236,21 @@ program
         const config = loadConfig();
         const manualList = config.manualList || [];
 
-        if (!manualList.length) {
-            console.log(chalk.yellow('  Your manual list is empty.\n'));
-            return;
-        }
+        if (!manualList.length) { console.log(chalk.yellow('  Your manual list is empty.\n')); return; }
 
         let target = title;
-
-        // If no title given, show interactive picker
         if (!target) {
             const { picked } = await inquirer.prompt([{
-                type:    'list',
-                name:    'picked',
-                message: 'Select anime to remove:',
-                choices: manualList.map(m => ({
-                    name:  `${m.title}${m.enabled ? '' : chalk.gray(' (disabled)')}`,
-                    value: m.title,
-                })),
+                type: 'list', name: 'picked', message: 'Select anime to remove:',
+                choices: manualList.map(m => ({ name: `${m.title}${m.enabled ? '' : chalk.gray(' (disabled)')}`, value: m.title })),
             }]);
             target = picked;
         }
 
         const exists = manualList.find(m => m.title.toLowerCase() === target.toLowerCase());
-        if (!exists) {
-            console.log(chalk.yellow(`  "${target}" is not in your manual list.\n`));
-            return;
-        }
+        if (!exists) { console.log(chalk.yellow(`  "${target}" is not in your manual list.\n`)); return; }
 
-        const { confirm } = await inquirer.prompt([{
-            type:    'confirm',
-            name:    'confirm',
-            message: `Remove "${target}" and all its episode history?`,
-            default: false,
-        }]);
+        const { confirm } = await inquirer.prompt([{ type: 'confirm', name: 'confirm', message: `Remove "${target}" and all its episode history?`, default: false }]);
         if (!confirm) return;
 
         updateConfig({ manualList: manualList.filter(m => m.title.toLowerCase() !== target.toLowerCase()) });
@@ -352,36 +258,25 @@ program
         console.log(chalk.green(`  ✔  Removed "${target}".\n`));
     });
 
-// ── enable / disable ──────────────────────────────────────────────────────
-
 async function pickFromWatchList(message) {
     const { resolveWatchList } = require('./engine');
     const config = loadConfig();
     const watchList = await resolveWatchList(config);
 
-    if (!watchList.length) {
-        console.log(chalk.yellow('  Watch list is empty.\n'));
-        return null;
-    }
+    if (!watchList.length) { console.log(chalk.yellow('  Watch list is empty.\n')); return null; }
 
     console.log(chalk.bold('\n  Watch list:'));
-    watchList.forEach((item, i) => {
-        console.log(`  ${chalk.cyan(i + 1)}. ${item.title}`);
-    });
+    watchList.forEach((item, i) => console.log(`  ${chalk.cyan(i + 1)}. ${item.title}`));
     console.log('');
 
     const { input } = await inquirer.prompt([{
-        type:     'input',
-        name:     'input',
-        message,
+        type: 'input', name: 'input', message,
         validate: (val) => {
             const n = parseInt(val.trim());
-            if (isNaN(n) || n < 1 || n > watchList.length)
-                return `Enter a number between 1 and ${watchList.length}`;
+            if (isNaN(n) || n < 1 || n > watchList.length) return `Enter a number between 1 and ${watchList.length}`;
             return true;
         }
     }]);
-
     return watchList[parseInt(input.trim()) - 1];
 }
 
@@ -407,8 +302,6 @@ program
         console.log(chalk.yellow(`\n  ✔  Disabled "${item.title}".\n`));
     });
 
-// ── status ────────────────────────────────────────────────────────────────
-
 program
     .command('status')
     .description('Show recent run log')
@@ -417,30 +310,20 @@ program
         banner();
         await db.initDb();
         const runs = db.getRecentRuns(parseInt(opts.runs, 10));
-        if (!runs.length) {
-            console.log(chalk.yellow('  No runs recorded yet. Run `ani-auto check` to start.\n'));
-            return;
-        }
+        if (!runs.length) { console.log(chalk.yellow('  No runs recorded yet. Run `ani-auto check` to start.\n')); return; }
 
         console.log(chalk.bold(`  ${'Time'.padEnd(20)} ${'Downloaded'.padEnd(12)} ${'Skipped'.padEnd(10)} Failed`));
         console.log('  ' + '─'.repeat(55));
         for (const run of runs) {
-            console.log(
-                `  ${run.ran_at.padEnd(20)} ` +
-                `${chalk.green(String(run.downloaded).padEnd(12))}` +
-                `${chalk.gray(String(run.skipped).padEnd(10))}` +
-                `${chalk.red(run.failed)}`
-            );
+            console.log(`  ${run.ran_at.padEnd(20)} ${chalk.green(String(run.downloaded).padEnd(12))}${chalk.gray(String(run.skipped).padEnd(10))}${chalk.red(run.failed)}`);
         }
         console.log('');
     });
 
-// ── config ────────────────────────────────────────────────────────────────
-
 program
     .command('config')
     .description('View, update, or open config file')
-    .option('--open', 'Open config file in default editor')
+    .option('--open',                   'Open config file in default editor')
     .option('--set-quality <quality>',  'Set default quality (e.g. 1080p)')
     .option('--set-language <lang>',    'Set default language (sub/dub)')
     .option('--set-concurrency <n>',    'Set parallel download count')
@@ -456,54 +339,39 @@ program
             const configPath = getConfigPath();
             const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
             console.log(chalk.cyan(`  Opening config in ${editor}: ${configPath}\n`));
-            try {
-                execSync(`${editor} "${configPath}"`, { stdio: 'inherit' });
-            } catch (e) {
-                console.log(chalk.yellow(`  Could not open editor. Config is at: ${configPath}`));
-            }
+            try { execSync(`${editor} "${configPath}"`, { stdio: 'inherit' }); }
+            catch (e) { console.log(chalk.yellow(`  Could not open editor. Config is at: ${configPath}`)); }
             return;
         }
 
         const updates = {};
-        if (opts.setQuality)    updates.quality               = opts.setQuality;
-        if (opts.setLanguage)   updates.language              = opts.setLanguage;
-        if (opts.setConcurrency)updates.concurrency           = parseInt(opts.setConcurrency, 10);
-        if (opts.setOutput)     updates.outputDir             = opts.setOutput;
-        if (opts.setInterval)   updates.daemonIntervalMinutes = parseInt(opts.setInterval, 10);
-        if (opts.setCron)       updates.cronSchedule          = opts.setCron;
+        if (opts.setQuality)     updates.quality               = opts.setQuality;
+        if (opts.setLanguage)    updates.language              = opts.setLanguage;
+        if (opts.setConcurrency) updates.concurrency           = parseInt(opts.setConcurrency, 10);
+        if (opts.setOutput)      updates.outputDir             = opts.setOutput;
+        if (opts.setInterval)    updates.daemonIntervalMinutes = parseInt(opts.setInterval, 10);
+        if (opts.setCron)        updates.cronSchedule          = opts.setCron;
 
         if (Object.keys(updates).length) {
-            const config = updateConfig(updates);
+            updateConfig(updates);
             console.log(chalk.green('  ✔  Config updated:\n'));
-            for (const [k, v] of Object.entries(updates)) {
-                console.log(`     ${chalk.bold(k)}: ${v}`);
-            }
+            for (const [k, v] of Object.entries(updates)) console.log(`     ${chalk.bold(k)}: ${v}`);
         } else {
-            // Print full config
             const config = loadConfig();
             console.log(chalk.bold('  Current configuration:\n'));
             for (const [k, v] of Object.entries(config)) {
-                if (k === 'anilistToken' && v) {
-                    console.log(`  ${chalk.cyan(k.padEnd(26))} ${chalk.gray('[set]')}`);
-                } else {
-                    console.log(`  ${chalk.cyan(k.padEnd(26))} ${JSON.stringify(v)}`);
-                }
+                if (k === 'anilistToken' && v) console.log(`  ${chalk.cyan(k.padEnd(26))} ${chalk.gray('[set]')}`);
+                else console.log(`  ${chalk.cyan(k.padEnd(26))} ${JSON.stringify(v)}`);
             }
         }
         console.log('');
     });
 
-// ── daemon ────────────────────────────────────────────────────────────────
-
 program
     .command('daemon')
     .description('Start the background daemon')
     .option('--auto', 'Skip prompts, auto-select all (default: true for daemon)')
-    .action(() => {
-        require('./daemon');
-    });
-
-// ── Bootstrap ─────────────────────────────────────────────────────────────
+    .action(() => { require('./daemon'); });
 
 program
     .name('ani-auto')
@@ -511,7 +379,4 @@ program
     .description('Automatic anime episode downloader — AniList-aware')
     .parse(process.argv);
 
-if (!process.argv.slice(2).length) {
-    banner();
-    program.help();
-}
+if (!process.argv.slice(2).length) { banner(); program.help(); }

package/src/daemon.js

@@ -44,7 +44,7 @@ async function startDaemon() {
   ██╔══██║██║╚██╗██║██║     ██╔══██║██║   ██║   ██║   ██║   ██║
   ██║  ██║██║ ╚████║██║     ██║  ██║╚██████╔╝   ██║   ╚██████╔╝
   ╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝     ╚═╝  ╚═╝ ╚═════╝    ╚═╝    ╚═════╝ 
-            A N I M E   A U T O   D O W N L O A D E R  D A E M O N
+     A N I M E   A U T O   D O W N L O A D E R  D A E M O N
     `));
 
     console.log(chalk.cyan(`  Interval:  every ${config.daemonIntervalMinutes || 30} minutes`));

package/src/db.js

@@ -141,8 +141,15 @@ function getAllEnabledAnime() {
     return _all('SELECT * FROM anime WHERE enabled = 1');
 }
 
-function setAnimeEnabled(siteId, enabled) {
-    _run('UPDATE anime SET enabled = ? WHERE site_id = ?', [enabled ? 1 : 0, siteId]);
+function setAnimeEnabled(titleOrSiteId, enabled) {
+    // Try by title first, fall back to site_id
+    const byTitle = _get('SELECT id FROM anime WHERE LOWER(title) = LOWER(?)', [titleOrSiteId]);
+    if (byTitle) {
+        _run('UPDATE anime SET enabled = ? WHERE id = ?', [enabled ? 1 : 0, byTitle.id]);
+    } else {
+        _run('UPDATE anime SET enabled = ? WHERE site_id = ?', [enabled ? 1 : 0, titleOrSiteId]);
+    }
+    _save();
 }
 
 function removeAnime(siteId) {

package/src/engine.js

@@ -21,13 +21,19 @@ function ts()      { return new Date().toISOString().replace('T', ' ').slice(0,
 
 // ── Filename helpers ───────────────────────────────────────────────────────
 
-function buildFilename(title, episodeNum, season = null) {
-    const s = season ? `Season ${season} ` : '';
-    return `${title} ${s}Episode ${episodeNum}.mp4`;
+function buildFilename(title, episodeNum, season = null, displayEpisodeNum = null) {
+    const s  = season ? `Season ${season} ` : '';
+    const ep = displayEpisodeNum || episodeNum;
+    return `${title} ${s}Episode ${ep}.mp4`;
 }
 
 function buildFolderName(title) {
-    return title.replace(/[<>:"/\\|?*]/g, '').trim();
+    return title
+        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")  // normalize smart single quotes
+        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')  // normalize smart double quotes
+        .replace(/[<>:"/\\|?*]/g, '')                    // strip illegal path chars
+        .replace(/ +/g, ' ')                               // collapse spaces
+        .trim();
 }
 
 function detectSeason(title) {
@@ -94,7 +100,6 @@ async function resolveWatchList(config) {
 // ── Anime selector prompt ──────────────────────────────────────────────────
 
 async function promptAnimeSelection(watchList) {
-    // Show numbered list
     console.log(chalk.bold('\n  Available anime:'));
     watchList.forEach((item, i) => {
         const watched = item.watchedEpisodes ? chalk.gray(` (watched: ${item.watchedEpisodes})`) : '';
@@ -124,20 +129,18 @@ async function promptAnimeSelection(watchList) {
 
 // ── Per-anime download ─────────────────────────────────────────────────────
 
-async function processAnime(workItem, config, multiBar, auto = false) {
-    const q = workItem.quality  || config.quality  || '1080p';
-    const l = workItem.language || config.language || 'sub';
+async function processAnime(workItem, config, multiBar, auto = false, runQuality = null, runLanguage = null) {
+    const q = runQuality  || workItem.quality  || config.quality  || '1080p';
+    const l = runLanguage || workItem.language || config.language || 'sub';
 
     // Check if we already have a confirmed site match saved in DB
     const existingRow = db.getAnimeBySiteTitle(workItem.title);
     let siteAnime;
 
     if (existingRow?.confirmed_site_id) {
-        // Already confirmed before — use saved match directly
         siteAnime = { session: existingRow.confirmed_site_id, title: existingRow.confirmed_site_title };
         info(`[${workItem.title}] Using saved site match: ${chalk.bold(siteAnime.title)}`);
     } else if (auto) {
-        // Auto mode — use top search result, save it
         const siteResults = await scraper.searchAll(workItem.title);
         if (!siteResults.length) {
             warn(`[${workItem.title}] Not found on site — skipping.`);
@@ -147,16 +150,13 @@ async function processAnime(workItem, config, multiBar, auto = false) {
         db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title);
         info(`[${workItem.title}] Auto-matched to: ${chalk.bold(siteAnime.title)}`);
     } else {
-        // Search and ask user to confirm
         const siteResults = await scraper.searchAll(workItem.title);
-
         if (!siteResults.length) {
             warn(`[${workItem.title}] Not found on site — skipping.`);
             return { downloaded: 0, skipped: 0, failed: 0 };
         }
 
         const topResults = siteResults.slice(0, 5);
-
         const { pick } = await inquirer.prompt([{
             type:    'list',
             name:    'pick',
@@ -176,8 +176,6 @@ async function processAnime(workItem, config, multiBar, auto = false) {
         }
 
         siteAnime = pick;
-
-        // Save confirmed match to DB so daemon never prompts again
         db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title);
         ok(`[${workItem.title}] Site match saved: ${chalk.bold(siteAnime.title)}`);
     }
@@ -191,7 +189,9 @@ async function processAnime(workItem, config, multiBar, auto = false) {
         language:  workItem.language || null,
     });
 
-    if (!dbRow.enabled) {
+    // Check enabled flag by title (AniList title) to respect ani-auto disable
+    const enabledCheck = db.getAnimeBySiteTitle(workItem.title);
+    if (dbRow.enabled === 0 || enabledCheck?.enabled === 0) {
         info(`[${workItem.title}] Disabled — skipping.`);
         return { downloaded: 0, skipped: 0, failed: 0 };
     }
@@ -209,16 +209,10 @@ async function processAnime(workItem, config, multiBar, auto = false) {
         return { downloaded: 0, skipped: 0, failed: 0 };
     }
 
-    // Sort episodes ascending by episode number
     const sortedEpisodes = [...episodes].sort((a, b) => a.episode - b.episode);
-
-    // AniList progress = episodes watched *within this season/entry*.
-    // The site may use absolute episode numbers (e.g. S2E1 = EP25).
-    // So we skip the first N episodes by position, not by episode number.
-    const watched = workItem.watchedEpisodes || 0;
-    const unwatched = sortedEpisodes.slice(watched);
-
-    const toDownload = unwatched.filter(ep => !db.isEpisodeDownloaded(dbRow.id, ep.episode));
+    const watched        = workItem.watchedEpisodes || 0;
+    const unwatched      = sortedEpisodes.slice(watched);
+    const toDownload     = unwatched.filter(ep => !db.isEpisodeDownloaded(dbRow.id, ep.episode));
 
     if (!toDownload.length) {
         info(`[${workItem.title}] Nothing new (watched ${watched}/${sortedEpisodes.length} episodes).`);
@@ -227,9 +221,12 @@ async function processAnime(workItem, config, multiBar, auto = false) {
 
     info(`[${workItem.title}] ${toDownload.length} unwatched episode(s) to download (Q:${q} L:${l}, skipping first ${watched}).`);
 
-    const cleanTitle = buildFolderName(siteAnime.title || workItem.title);
-    const season     = detectSeason(cleanTitle);
-    const outputDir  = path.join(config.outputDir, cleanTitle);
+    // Use AniList title for folder — consistent with what user sees on AniList
+    const cleanTitle  = buildFolderName(workItem.title);
+    const season      = detectSeason(workItem.title);
+    // Strip "Season X" from the display title used in filename to avoid duplication
+    const displayTitle = cleanTitle.replace(/\s*season\s*\d+\s*/gi, '').trim();
+    const outputDir   = path.join(config.outputDir, cleanTitle);
     if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
 
     const queue       = [...toDownload];
@@ -248,11 +245,16 @@ async function processAnime(workItem, config, multiBar, auto = false) {
             while (!success && attempts < MAX_RETRIES) {
                 attempts++;
                 try {
-                    const links    = await scraper.getDownloadLinks(siteAnime.session, ep.session);
-                    const link     = scraper.pickLink(links, q, l);
+                    const links = await scraper.getDownloadLinks(siteAnime.session, ep.session);
+                    const link  = scraper.pickLink(links, q, l);
                     if (!link?.mp4Url) throw new Error('No suitable download link found');
 
-                    const filename = buildFilename(cleanTitle, ep.episode, season);
+                    // Per-season site listing: position in sortedEpisodes = season episode number
+                    const relativeEp = season
+                        ? sortedEpisodes.findIndex(e => e.episode === ep.episode) + 1
+                        : ep.episode;
+
+                    const filename = buildFilename(displayTitle, ep.episode, season, relativeEp);
                     await scraper.downloadEpisode(link.mp4Url, filename, outputDir, multiBar, ep.episode);
 
                     db.markEpisodeStatus(dbRow.id, ep.episode, 'done', filename);
@@ -279,7 +281,7 @@ async function processAnime(workItem, config, multiBar, auto = false) {
 
 // ── Main cycle ─────────────────────────────────────────────────────────────
 
-async function runCycle({ auto = false } = {}) {
+async function runCycle({ auto = false, quality = null, language = null } = {}) {
     await db.initDb();
     const config = loadConfig();
 
@@ -321,7 +323,7 @@ async function runCycle({ auto = false } = {}) {
     const totals = { downloaded: 0, skipped: 0, failed: 0 };
 
     for (const item of selected) {
-        const result = await processAnime(item, config, multiBar, auto);
+        const result = await processAnime(item, config, multiBar, auto, quality, language);
         totals.downloaded += result.downloaded;
         totals.skipped    += result.skipped;
         totals.failed     += result.failed;

package/src/scraper.js

@@ -55,7 +55,9 @@ async function searchAnime(title) {
 /** Returns all search results (up to API limit) for user confirmation. */
 async function searchAll(title) {
     const { SEARCH_API, USER_AGENT } = utils();
-    const url = `${SEARCH_API}?q=${encodeURIComponent(title)}`;
+    // Strip special characters that confuse the search API
+    const cleaned = title.replace(/[-–—~:!?()[\]{}<>]/g, ' ').replace(/\s+/g, ' ').trim();
+    const url = `${SEARCH_API}?q=${encodeURIComponent(cleaned)}`;
     const res = await fetch(url, { headers: { 'User-Agent': USER_AGENT } });
     if (!res.ok) return [];
     const data = await res.json();