ani-auto 1.0.0

package/src/db.js

@@ -0,0 +1,232 @@
+'use strict';
+
+/**
+ * db.js — SQLite state layer using sql.js (pure WASM, no native compilation).
+ * Drop-in replacement for the better-sqlite3 version.
+ * Compatible with Node v25+ without any C++ compilation.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const DB_DIR  = path.join(os.homedir(), '.config', 'ani-auto');
+const DB_PATH = path.join(DB_DIR, 'state.db');
+
+let _db = null;
+
+/**
+ * Async init — call once at startup before any DB operations.
+ */
+async function initDb() {
+    if (_db) return _db;
+
+    if (!fs.existsSync(DB_DIR)) fs.mkdirSync(DB_DIR, { recursive: true });
+
+    const initSqlJs = require('sql.js');
+    const SQL = await initSqlJs();
+
+    if (fs.existsSync(DB_PATH)) {
+        const fileBuffer = fs.readFileSync(DB_PATH);
+        _db = new SQL.Database(fileBuffer);
+    } else {
+        _db = new SQL.Database();
+    }
+
+    migrate(_db);
+    return _db;
+}
+
+function _save() {
+    if (!_db) return;
+    const data = _db.export();
+    fs.writeFileSync(DB_PATH, Buffer.from(data));
+}
+
+function migrate(db) {
+    db.run(`
+        CREATE TABLE IF NOT EXISTS anime (
+            id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+            title                TEXT    NOT NULL,
+            site_id              TEXT    NOT NULL UNIQUE,
+            anilist_id           INTEGER,
+            source               TEXT    NOT NULL DEFAULT 'anilist',
+            enabled              INTEGER NOT NULL DEFAULT 1,
+            quality              TEXT,
+            language             TEXT,
+            confirmed_site_id    TEXT,
+            confirmed_site_title TEXT,
+            added_at             TEXT    NOT NULL DEFAULT (datetime('now'))
+        )
+    `);
+    db.run(`
+        CREATE TABLE IF NOT EXISTS episodes (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            anime_id      INTEGER NOT NULL,
+            episode_num   INTEGER NOT NULL,
+            status        TEXT    NOT NULL DEFAULT 'pending',
+            filename      TEXT,
+            downloaded_at TEXT,
+            error         TEXT,
+            UNIQUE(anime_id, episode_num)
+        )
+    `);
+    // Add confirmed_site columns if upgrading from older DB
+    try { db.run('ALTER TABLE anime ADD COLUMN confirmed_site_id TEXT'); } catch(e) {}
+    try { db.run('ALTER TABLE anime ADD COLUMN confirmed_site_title TEXT'); } catch(e) {}
+
+    db.run(`
+        CREATE TABLE IF NOT EXISTS run_log (
+            id         INTEGER PRIMARY KEY AUTOINCREMENT,
+            ran_at     TEXT    NOT NULL DEFAULT (datetime('now')),
+            downloaded INTEGER NOT NULL DEFAULT 0,
+            skipped    INTEGER NOT NULL DEFAULT 0,
+            failed     INTEGER NOT NULL DEFAULT 0,
+            notes      TEXT
+        )
+    `);
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function _assertReady() {
+    if (!_db) throw new Error('DB not initialised — call initDb() first at startup.');
+}
+
+function _get(sql, params = []) {
+    _assertReady();
+    const stmt = _db.prepare(sql);
+    stmt.bind(params);
+    const row = stmt.step() ? stmt.getAsObject() : null;
+    stmt.free();
+    return row;
+}
+
+function _all(sql, params = []) {
+    _assertReady();
+    const results = [];
+    const stmt = _db.prepare(sql);
+    stmt.bind(params);
+    while (stmt.step()) results.push(stmt.getAsObject());
+    stmt.free();
+    return results;
+}
+
+function _run(sql, params = []) {
+    _assertReady();
+    _db.run(sql, params);
+    _save();
+}
+
+// ── Anime ──────────────────────────────────────────────────────────────────
+
+function upsertAnime({ title, siteId, anilistId, source, quality, language }) {
+    _run(`
+        INSERT INTO anime (title, site_id, anilist_id, source, quality, language)
+        VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(site_id) DO UPDATE SET
+            title      = excluded.title,
+            anilist_id = COALESCE(excluded.anilist_id, anime.anilist_id),
+            quality    = COALESCE(excluded.quality, anime.quality),
+            language   = COALESCE(excluded.language, anime.language)
+    `, [title, siteId || title, anilistId || null, source || 'anilist', quality || null, language || null]);
+    return _get('SELECT * FROM anime WHERE site_id = ?', [siteId || title]);
+}
+
+function getAnime(siteId) {
+    return _get('SELECT * FROM anime WHERE site_id = ?', [siteId]);
+}
+
+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 removeAnime(siteId) {
+    const row = _get('SELECT id FROM anime WHERE site_id = ?', [siteId]);
+    if (!row) return;
+    _run('DELETE FROM episodes WHERE anime_id = ?', [row.id]);
+    _run('DELETE FROM anime WHERE id = ?', [row.id]);
+}
+
+// ── Episodes ───────────────────────────────────────────────────────────────
+
+function isEpisodeDownloaded(animeDbId, episodeNum) {
+    return !!_get(
+        "SELECT id FROM episodes WHERE anime_id = ? AND episode_num = ? AND status = 'done'",
+        [animeDbId, episodeNum]
+    );
+}
+
+function markEpisodeStatus(animeDbId, episodeNum, status, filename = null, error = null) {
+    _run(`
+        INSERT INTO episodes (anime_id, episode_num, status, filename, downloaded_at, error)
+        VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(anime_id, episode_num) DO UPDATE SET
+            status        = excluded.status,
+            filename      = COALESCE(excluded.filename, episodes.filename),
+            downloaded_at = excluded.downloaded_at,
+            error         = excluded.error
+    `, [
+        animeDbId, episodeNum, status, filename || null,
+        status === 'done' ? new Date().toISOString() : null,
+        error || null,
+    ]);
+}
+
+function getEpisodeStats(animeDbId) {
+    return {
+        done:    (_get("SELECT COUNT(*) as c FROM episodes WHERE anime_id = ? AND status = 'done'",    [animeDbId])?.c || 0),
+        failed:  (_get("SELECT COUNT(*) as c FROM episodes WHERE anime_id = ? AND status = 'failed'",  [animeDbId])?.c || 0),
+        pending: (_get("SELECT COUNT(*) as c FROM episodes WHERE anime_id = ? AND status = 'pending'", [animeDbId])?.c || 0),
+    };
+}
+
+// ── Run log ────────────────────────────────────────────────────────────────
+
+function logRun({ downloaded, skipped, failed, notes }) {
+    _run('INSERT INTO run_log (downloaded, skipped, failed, notes) VALUES (?, ?, ?, ?)',
+        [downloaded, skipped, failed, notes || null]);
+}
+
+function getRecentRuns(limit = 10) {
+    return _all('SELECT * FROM run_log ORDER BY id DESC LIMIT ?', [limit]);
+}
+
+function getDbInstance() {
+    _assertReady();
+    return _db;
+}
+
+function getAnimeBySiteTitle(title) {
+    return _get('SELECT * FROM anime WHERE LOWER(title) = LOWER(?)', [title]);
+}
+
+function saveConfirmedSiteMatch(title, confirmedSiteId, confirmedSiteTitle) {
+    // Try to update existing row first
+    const existing = _get('SELECT id FROM anime WHERE LOWER(title) = LOWER(?)', [title]);
+    if (existing) {
+        _run(
+            'UPDATE anime SET confirmed_site_id = ?, confirmed_site_title = ? WHERE id = ?',
+            [confirmedSiteId, confirmedSiteTitle, existing.id]
+        );
+    } else {
+        // No row yet — insert one using confirmedSiteId as the site_id
+        _run(
+            'INSERT OR IGNORE INTO anime (title, site_id, confirmed_site_id, confirmed_site_title, source) VALUES (?, ?, ?, ?, ?)',
+            [title, confirmedSiteId, confirmedSiteId, confirmedSiteTitle, 'anilist']
+        );
+    }
+    _save();
+}
+
+module.exports = {
+    initDb,
+    getDb: getDbInstance,
+    upsertAnime, getAnime, getAnimeBySiteTitle, saveConfirmedSiteMatch, getAllEnabledAnime, setAnimeEnabled, removeAnime,
+    isEpisodeDownloaded, markEpisodeStatus, getEpisodeStats,
+    logRun, getRecentRuns,
+};

package/src/engine.js

@@ -0,0 +1,343 @@
+'use strict';
+
+const fs       = require('fs');
+const path     = require('path');
+const chalk    = require('chalk');
+const inquirer = require('inquirer');
+const cliProgress = require('cli-progress');
+
+const { loadConfig }             = require('./config');
+const db                         = require('./db');
+const { getUserList, pickTitle } = require('./anilist');
+const scraper                    = require('./scraper');
+
+// ── Logging ────────────────────────────────────────────────────────────────
+
+function info(msg) { console.log(`${chalk.gray(ts())} ${chalk.cyan('ℹ')}  ${msg}`); }
+function ok(msg)   { console.log(`${chalk.gray(ts())} ${chalk.green('✔')}  ${msg}`); }
+function warn(msg) { console.log(`${chalk.gray(ts())} ${chalk.yellow('⚠')}  ${msg}`); }
+function err(msg)  { console.log(`${chalk.gray(ts())} ${chalk.red('✖')}  ${msg}`); }
+function ts()      { return new Date().toISOString().replace('T', ' ').slice(0, 19); }
+
+// ── Filename helpers ───────────────────────────────────────────────────────
+
+function buildFilename(title, episodeNum, season = null) {
+    const s = season ? `Season ${season} ` : '';
+    return `${title} ${s}Episode ${episodeNum}.mp4`;
+}
+
+function buildFolderName(title) {
+    return title.replace(/[<>:"/\\|?*]/g, '').trim();
+}
+
+function detectSeason(title) {
+    const m = title.match(/\bseason\s*(\d+)\b/i)
+            || title.match(/\b(\d+)(?:st|nd|rd|th)\s+season\b/i)
+            || title.match(/\bS(\d{2})\b/);
+    return m ? parseInt(m[1], 10) : null;
+}
+
+// ── Watch list ─────────────────────────────────────────────────────────────
+
+async function resolveWatchList(config) {
+    const items = [];
+
+    if (config.anilistUsername && config.watchStatuses?.length) {
+        info(`Fetching AniList list for ${chalk.bold(config.anilistUsername)} (${config.watchStatuses.join(', ')})...`);
+        try {
+            const entries = await getUserList(
+                config.anilistUsername,
+                config.watchStatuses,
+                config.anilistToken || null
+            );
+            for (const entry of entries) {
+                items.push({
+                    title:           pickTitle(entry.titles),
+                    anilistId:       entry.anilistId,
+                    source:          'anilist',
+                    quality:         null,
+                    language:        null,
+                    watchedEpisodes: entry.progress || 0,
+                    knownEpisodes:   entry.totalEpisodes,
+                    animeStatus:     entry.animeStatus,
+                });
+            }
+            info(`AniList returned ${chalk.bold(entries.length)} entries.`);
+        } catch (e) {
+            warn(`AniList fetch failed: ${e.message}`);
+        }
+    }
+
+    for (const manual of (config.manualList || [])) {
+        if (!manual.enabled) continue;
+        items.push({
+            title:           manual.title,
+            anilistId:       manual.anilistId || null,
+            source:          'manual',
+            quality:         manual.quality  || null,
+            language:        manual.language || null,
+            watchedEpisodes: 0,
+            knownEpisodes:   null,
+            animeStatus:     null,
+        });
+    }
+
+    const seen = new Set();
+    return items.filter(item => {
+        const key = item.title.toLowerCase();
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+    });
+}
+
+// ── 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})`) : '';
+        console.log(`  ${chalk.cyan(i + 1)}. ${item.title}${watched}`);
+    });
+    console.log(`  ${chalk.cyan('a')}. All`);
+    console.log('');
+
+    const { input } = await inquirer.prompt([{
+        type:    'input',
+        name:    'input',
+        message: 'Enter numbers to download (e.g. 1,3 or "a" for all):',
+        default: 'a',
+        validate: (val) => {
+            if (val.trim().toLowerCase() === 'a') return true;
+            const nums = val.split(',').map(s => parseInt(s.trim()));
+            if (nums.some(isNaN)) return 'Enter comma-separated numbers or "a"';
+            if (nums.some(n => n < 1 || n > watchList.length)) return `Numbers must be between 1 and ${watchList.length}`;
+            return true;
+        }
+    }]);
+
+    if (input.trim().toLowerCase() === 'a') return watchList;
+    const indices = input.split(',').map(s => parseInt(s.trim()) - 1);
+    return indices.map(i => watchList[i]);
+}
+
+// ── 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';
+
+    // 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.`);
+            return { downloaded: 0, skipped: 0, failed: 0 };
+        }
+        siteAnime = siteResults[0];
+        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',
+            message: `Site results for "${workItem.title}" — select correct match:`,
+            choices: [
+                ...topResults.map(r => ({
+                    name:  `${r.title} ${chalk.gray(`(${r.year || '?'}) — ${r.episodes || '?'} eps`)}`,
+                    value: r,
+                })),
+                { name: chalk.yellow('Skip this anime'), value: null },
+            ],
+        }]);
+
+        if (!pick) {
+            info(`[${workItem.title}] Skipped by user.`);
+            return { downloaded: 0, skipped: 0, failed: 0 };
+        }
+
+        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)}`);
+    }
+
+    const dbRow = db.upsertAnime({
+        title:     siteAnime.title || workItem.title,
+        siteId:    siteAnime.session,
+        anilistId: workItem.anilistId || null,
+        source:    workItem.source,
+        quality:   workItem.quality  || null,
+        language:  workItem.language || null,
+    });
+
+    if (!dbRow.enabled) {
+        info(`[${workItem.title}] Disabled — skipping.`);
+        return { downloaded: 0, skipped: 0, failed: 0 };
+    }
+
+    let episodes;
+    try {
+        episodes = await scraper.getEpisodes(siteAnime.session);
+    } catch (e) {
+        warn(`[${workItem.title}] Could not fetch episodes: ${e.message}`);
+        return { downloaded: 0, skipped: 0, failed: 1 };
+    }
+
+    if (!episodes.length) {
+        info(`[${workItem.title}] No episodes available yet.`);
+        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));
+
+    if (!toDownload.length) {
+        info(`[${workItem.title}] Nothing new (watched ${watched}/${sortedEpisodes.length} episodes).`);
+        return { downloaded: 0, skipped: episodes.length, failed: 0 };
+    }
+
+    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);
+    if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+
+    const queue       = [...toDownload];
+    const results     = { downloaded: 0, skipped: 0, failed: 0 };
+    const concurrency = Math.min(config.concurrency || 2, queue.length);
+    const MAX_RETRIES = config.maxRetries || 3;
+
+    const workers = Array(concurrency).fill(0).map(async () => {
+        while (queue.length > 0) {
+            const ep     = queue.shift();
+            let success  = false;
+            let attempts = 0;
+
+            db.markEpisodeStatus(dbRow.id, ep.episode, 'downloading');
+
+            while (!success && attempts < MAX_RETRIES) {
+                attempts++;
+                try {
+                    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);
+                    await scraper.downloadEpisode(link.mp4Url, filename, outputDir, multiBar, ep.episode);
+
+                    db.markEpisodeStatus(dbRow.id, ep.episode, 'done', filename);
+                    ok(`[${cleanTitle}] EP${ep.episode} → ${filename}`);
+                    success = true;
+                    results.downloaded++;
+                } catch (e) {
+                    if (attempts >= MAX_RETRIES) {
+                        err(`[${workItem.title}] EP${ep.episode} failed: ${e.message}`);
+                        db.markEpisodeStatus(dbRow.id, ep.episode, 'failed', null, e.message);
+                        results.failed++;
+                    } else {
+                        warn(`[${workItem.title}] EP${ep.episode} attempt ${attempts} failed, retrying...`);
+                        await sleep(2000 * attempts);
+                    }
+                }
+            }
+        }
+    });
+
+    await Promise.all(workers);
+    return results;
+}
+
+// ── Main cycle ─────────────────────────────────────────────────────────────
+
+async function runCycle({ auto = false } = {}) {
+    await db.initDb();
+    const config = loadConfig();
+
+    console.log(chalk.bold.red('\n  ╔══════════════════════════════╗'));
+    console.log(chalk.bold.red('  ║      ANI-AUTO — CHECK RUN    ║'));
+    console.log(chalk.bold.red('  ╚══════════════════════════════╝\n'));
+
+    const watchList = await resolveWatchList(config);
+
+    if (!watchList.length) {
+        warn('Watch list is empty. Add entries via AniList or `ani-auto add`.');
+        db.logRun({ downloaded: 0, skipped: 0, failed: 0, notes: 'empty watch list' });
+        return;
+    }
+
+    let selected;
+    if (auto) {
+        selected = watchList;
+        info(`Auto mode: processing all ${chalk.bold(watchList.length)} anime.`);
+    } else {
+        selected = await promptAnimeSelection(watchList);
+        if (!selected.length) {
+            warn('No anime selected — exiting.');
+            return;
+        }
+    }
+
+    info(`Processing ${chalk.bold(selected.length)} anime.`);
+
+    const multiBar = new cliProgress.MultiBar({
+        clearOnDone: false,
+        hideCursor:  true,
+        format: `${chalk.blue('{bar}')} {percentage}% | {value_formatted}/{total_formatted} | EP:{episode}`,
+        barCompleteChar:   '\u2588',
+        barIncompleteChar: '\u2591',
+        barsize: 30,
+    }, cliProgress.Presets.shades_classic);
+
+    const totals = { downloaded: 0, skipped: 0, failed: 0 };
+
+    for (const item of selected) {
+        const result = await processAnime(item, config, multiBar, auto);
+        totals.downloaded += result.downloaded;
+        totals.skipped    += result.skipped;
+        totals.failed     += result.failed;
+    }
+
+    multiBar.stop();
+
+    console.log(chalk.bold('\n  ── Run Summary ──────────────────────'));
+    console.log(`  ${chalk.green('Downloaded:')} ${totals.downloaded}`);
+    console.log(`  ${chalk.gray('Skipped:')}    ${totals.skipped}`);
+    console.log(`  ${chalk.red('Failed:')}     ${totals.failed}`);
+    console.log(chalk.bold('  ─────────────────────────────────────\n'));
+
+    db.logRun(totals);
+}
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+module.exports = { runCycle, resolveWatchList };