kagami-cli 0.1.0

package/README.md

@@ -0,0 +1,21 @@
+# @kagami/cli
+
+CLI tool for Kagami manga parser with interactive interface.
+
+## Installation
+
+```bash
+npm install -g @kagami/cli
+```
+
+## Usage
+
+```bash
+kagami "<search-query>"
+```
+
+Interactive workflow: select source → search → view results → select manga → download chapters
+
+## License
+
+MIT

package/dist/args.d.ts

@@ -0,0 +1,27 @@
+import commandLineArgs from 'command-line-args';
+export declare const optionDefinitions: ({
+    name: string;
+    alias: string;
+    type: BooleanConstructor;
+    description: string;
+    multiple?: undefined;
+    defaultOption?: undefined;
+} | {
+    name: string;
+    type: StringConstructor;
+    description: string;
+    alias?: undefined;
+    multiple?: undefined;
+    defaultOption?: undefined;
+} | {
+    name: string;
+    type: StringConstructor;
+    multiple: boolean;
+    defaultOption: boolean;
+    description: string;
+    alias?: undefined;
+})[];
+export declare function showUsage(): void;
+export declare function showInstallHelp(): void;
+export declare function parseArgs(): commandLineArgs.CommandLineOptions;
+//# sourceMappingURL=args.d.ts.map

package/dist/args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../src/args.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,mBAAmB,CAAC;AAGhD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;IAK7B,CAAC;AAgDF,wBAAgB,SAAS,SAExB;AAED,wBAAgB,eAAe,SAE9B;AAED,wBAAgB,SAAS,uCAExB"}

package/dist/args.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionDefinitions = void 0;
+exports.showUsage = showUsage;
+exports.showInstallHelp = showInstallHelp;
+exports.parseArgs = parseArgs;
+const command_line_args_1 = __importDefault(require("command-line-args"));
+const command_line_usage_1 = __importDefault(require("command-line-usage"));
+exports.optionDefinitions = [
+    { name: 'help', alias: 'h', type: Boolean, description: 'Show this help message' },
+    { name: 'install', type: String, description: 'Install a plugin source (e.g. mangadex) or local path' },
+    { name: 'link', type: String, description: 'Download directly from URL (e.g. https://mangadex.org/title/...)' },
+    { name: 'query', type: String, multiple: true, defaultOption: true, description: 'Search query for manga' },
+];
+const sections = [
+    {
+        header: 'Kagami',
+        content: 'CLI tool for downloading manga from various sources.'
+    },
+    {
+        header: 'Usage',
+        content: [
+            '$ kagami <search-query>',
+            '$ kagami --link=<url>',
+            '$ kagami --install <sourcename>',
+            '$ kagami --install <path-to-local-plugin>'
+        ]
+    },
+    {
+        header: 'Options',
+        optionList: exports.optionDefinitions.filter(opt => opt.name !== 'query')
+    },
+    {
+        header: 'Examples',
+        content: [
+            '$ kagami "Toaru no Index"',
+            '$ kagami --link=https://mangadex.org/title/...',
+            '$ kagami --install mangadex',
+        ]
+    }
+];
+const installSections = [
+    {
+        header: 'No sources found',
+        content: 'Add source via installation command:'
+    },
+    {
+        header: 'Install Commands',
+        optionList: exports.optionDefinitions.filter(opt => opt.name === 'install')
+    },
+    {
+        header: 'Examples',
+        content: [
+            '$ kagami --install mangadex',
+            '$ kagami --install ./packages/plugin-mangadex'
+        ]
+    }
+];
+function showUsage() {
+    console.log((0, command_line_usage_1.default)(sections));
+}
+function showInstallHelp() {
+    console.log((0, command_line_usage_1.default)(installSections));
+}
+function parseArgs() {
+    return (0, command_line_args_1.default)(exports.optionDefinitions, { argv: process.argv.slice(2) });
+}

package/dist/download.d.ts

@@ -0,0 +1,3 @@
+import { IManga, IPlugin } from '@kagami/plugin';
+export declare function downloadManga(manga: IManga, plugin: IPlugin): Promise<void>;
+//# sourceMappingURL=download.d.ts.map

package/dist/download.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"download.d.ts","sourceRoot":"","sources":["../src/download.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAY,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAS3D,wBAAsB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,iBAqHjE"}

package/dist/download.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadManga = downloadManga;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cli_progress_1 = require("cli-progress");
+const OUTPUT_DIR = './downloads';
+function getMangaName(manga) {
+    return Array.isArray(manga.name) ? manga.name[0] : manga.name;
+}
+function downloadManga(manga, plugin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const mangaName = getMangaName(manga);
+        console.log(`\nDownloading: ${mangaName} from ${manga.source}`);
+        const safeName = mangaName.replace(/[\/\\:*?"<>|]/g, '_');
+        const mangaDir = path.join(OUTPUT_DIR, manga.source, safeName);
+        fs.mkdirSync(mangaDir, { recursive: true });
+        // Download covers
+        if (manga.covers && manga.covers.length > 0) {
+            const coversDir = path.join(mangaDir, 'covers');
+            fs.mkdirSync(coversDir, { recursive: true });
+            console.log(`Downloading ${manga.covers.length} cover(s)...`);
+            const coverBar = new cli_progress_1.SingleBar({}, cli_progress_1.Presets.shades_classic);
+            coverBar.start(manga.covers.length, 0);
+            for (let i = 0; i < manga.covers.length; i++) {
+                const cover = manga.covers[i];
+                const ext = ((_a = cover.url.split('.').pop()) === null || _a === void 0 ? void 0 : _a.split('?')[0]) || 'jpg';
+                const fileName = `cover-${i + 1}.${ext}`;
+                const filePath = path.join(coversDir, fileName);
+                if (fs.existsSync(filePath)) {
+                    coverBar.update(i + 1);
+                    continue;
+                }
+                try {
+                    const buffer = yield plugin.downloadImage(cover.url);
+                    fs.writeFileSync(filePath, Buffer.from(buffer));
+                }
+                catch (err) {
+                    const error = err;
+                    console.error(`\n  Error downloading cover ${fileName}: ${error.message || err}`);
+                }
+                coverBar.update(i + 1);
+                yield plugin.delay();
+            }
+            coverBar.stop();
+            console.log(` ✓ Covers downloaded`);
+        }
+        console.log('Fetching chapters...');
+        let chapters = [];
+        try {
+            chapters = yield plugin.getChapters(manga);
+        }
+        catch (err) {
+            const error = err;
+            console.error(`  Error fetching chapters from ${manga.source}: ${error.message || err}`);
+            if (err instanceof SyntaxError) {
+                console.error(`  (Invalid response from ${manga.source} - possible 403/404/network error)`);
+            }
+        }
+        yield plugin.delay();
+        if (!chapters || chapters.length === 0) {
+            console.log('No chapters found.');
+            return;
+        }
+        console.log(`Found ${chapters.length} chapters. Downloading...\n`);
+        for (const chapter of chapters) {
+            const chapterDir = path.join(mangaDir, `chapter-${chapter.number}`);
+            fs.mkdirSync(chapterDir, { recursive: true });
+            console.log(`Chapter ${chapter.number}: Fetching pages...`);
+            let pages = [];
+            try {
+                pages = yield plugin.getChapterPages(chapter);
+            }
+            catch (err) {
+                const error = err;
+                console.error(`  Error fetching pages for chapter ${chapter.number} from ${manga.source}: ${error.message || err}`);
+                if (err instanceof SyntaxError) {
+                    console.error(`  (Invalid response from ${manga.source} - possible 403/404/network error)`);
+                }
+            }
+            yield plugin.delay();
+            if (pages.length === 0) {
+                console.log('  No pages found, skipping.');
+                continue;
+            }
+            const bar = new cli_progress_1.SingleBar({}, cli_progress_1.Presets.shades_classic);
+            bar.start(pages.length, 0);
+            for (let i = 0; i < pages.length; i++) {
+                const page = pages[i];
+                const ext = ((_b = page.url.split('.').pop()) === null || _b === void 0 ? void 0 : _b.split('?')[0]) || 'jpg';
+                const fileName = `${String(i + 1).padStart(3, '0')}.${ext}`;
+                const filePath = path.join(chapterDir, fileName);
+                if (fs.existsSync(filePath)) {
+                    bar.update(i + 1);
+                    continue;
+                }
+                try {
+                    const buffer = yield plugin.downloadImage(page.url);
+                    fs.writeFileSync(filePath, Buffer.from(buffer));
+                }
+                catch (err) {
+                    const error = err;
+                    console.error(`\nError downloading ${page.url}: ${error.message || err}`);
+                }
+                bar.update(i + 1);
+                yield plugin.delay();
+            }
+            bar.stop();
+            console.log(` ✓ Chapter ${chapter.number} complete`);
+        }
+        console.log('\nDownload complete!');
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ui_1 = require("./ui");
+const download_1 = require("./download");
+const search_1 = require("./search");
+const plugins_1 = require("./plugins");
+const args_1 = require("./args");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        // Clear terminal and use full height
+        process.stdout.write('\x1b[2J\x1b[0;0H');
+        const options = (0, args_1.parseArgs)();
+        if (options.help) {
+            (0, args_1.showUsage)();
+            return;
+        }
+        if (options.install !== undefined) {
+            const sourceName = options.install;
+            if (!sourceName) {
+                (0, args_1.showUsage)();
+                return;
+            }
+            yield (0, plugins_1.installPlugin)(sourceName);
+            return;
+        }
+        const query = options.query ? options.query.join(' ') : null;
+        const link = options.link || null;
+        if (!query && !link) {
+            (0, args_1.showUsage)();
+            return;
+        }
+        const plugins = yield (0, plugins_1.discoverPlugins)();
+        if (Object.keys(plugins).length === 0) {
+            (0, args_1.showInstallHelp)();
+            return;
+        }
+        if (link) {
+            const plugin = Object.values(plugins).find(p => p.matchUrl(link));
+            if (!plugin) {
+                console.log('Unsupported URL or source not found.');
+                return;
+            }
+            const mangaId = plugin.extractMangaId(link);
+            if (!mangaId) {
+                console.log('Could not extract manga ID from URL.');
+                return;
+            }
+            const mangaInfo = yield plugin.getMangaInfo(mangaId);
+            const manga = {
+                source: plugin.key,
+                id: mangaId,
+                name: (_a = mangaInfo === null || mangaInfo === void 0 ? void 0 : mangaInfo.name) !== null && _a !== void 0 ? _a : mangaId
+            };
+            yield (0, search_1.prepareManga)(manga, plugin);
+            let chapters = [];
+            try {
+                chapters = yield plugin.getChapters(manga);
+                manga.chapters = chapters.length;
+            }
+            catch (err) {
+                console.error('Error fetching manga info:', err);
+                return;
+            }
+            console.log(`\nFound: ${manga.name} (${chapters.length} chapters)`);
+            const confirmed = yield (0, ui_1.confirmDownload)(manga);
+            if (!confirmed)
+                return;
+            yield (0, download_1.downloadManga)(manga, plugin);
+            return;
+        }
+        const sources = yield (0, ui_1.selectSources)(Object.keys(plugins));
+        if (sources.length === 0) {
+            console.log('No sources selected.');
+            return;
+        }
+        const results = yield (0, search_1.searchManga)(query, sources, plugins);
+        if (results.length === 0) {
+            console.log('No results found. Try a different query.');
+            return;
+        }
+        const selected = yield (0, ui_1.selectManga)(results, plugins);
+        for (const manga of selected) {
+            const plugin = plugins[manga.source];
+            if (plugin) {
+                yield (0, download_1.downloadManga)(manga, plugin);
+            }
+        }
+    });
+}
+main().catch(err => {
+    if ((err === null || err === void 0 ? void 0 : err.name) === 'ExitPromptError') {
+        process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+});

package/dist/plugins.d.ts

@@ -0,0 +1,4 @@
+import { IPlugin } from "@kagami/plugin";
+export declare function discoverPlugins(): Promise<Record<string, IPlugin>>;
+export declare function installPlugin(sourceName: string): Promise<void>;
+//# sourceMappingURL=plugins.d.ts.map

package/dist/plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../src/plugins.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAqCzC,wBAAsB,eAAe,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA6CxE;AAED,wBAAsB,aAAa,CAAC,UAAU,EAAE,MAAM,iBAsCrD"}

package/dist/plugins.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverPlugins = discoverPlugins;
+exports.installPlugin = installPlugin;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+function instantiatePlugin(PluginModule) {
+    // Try different export patterns
+    const PluginClass = PluginModule.default || // ES module default export
+        PluginModule.MangaDexPlugin || // Named export (mangadex)
+        PluginModule.MangaLibPlugin || // Named export (mangalib)
+        PluginModule; // Direct export
+    try {
+        const plugin = new PluginClass();
+        if (plugin.key && plugin.search) {
+            return plugin;
+        }
+    }
+    catch (_a) {
+        // If instantiation fails, try to find a class that can be instantiated
+        for (const key of Object.keys(PluginModule)) {
+            try {
+                const cls = PluginModule[key];
+                if (typeof cls === 'function') {
+                    const plugin = new cls();
+                    if (plugin.key && plugin.search) {
+                        return plugin;
+                    }
+                }
+            }
+            catch (_b) {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+function discoverPlugins() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cwd = process.cwd();
+        const nodeModules = path.join(cwd, 'node_modules');
+        const plugins = {};
+        if (!fs.existsSync(nodeModules))
+            return plugins;
+        // Check @kagami scope
+        const kagamiScope = path.join(nodeModules, '@kagami');
+        if (fs.existsSync(kagamiScope)) {
+            const dirs = fs.readdirSync(kagamiScope);
+            for (const dir of dirs) {
+                if (dir.startsWith('plugin-')) {
+                    try {
+                        const pkgPath = path.join(kagamiScope, dir);
+                        const PluginModule = require(pkgPath);
+                        const plugin = instantiatePlugin(PluginModule);
+                        if (plugin) {
+                            plugins[plugin.key] = plugin;
+                        }
+                    }
+                    catch (e) {
+                        console.warn(`Failed to load plugin @kagami/${dir}:`, e);
+                    }
+                }
+            }
+        }
+        // Check unscoped kagami-plugin-*
+        const allDirs = fs.readdirSync(nodeModules);
+        for (const dir of allDirs) {
+            if (dir.startsWith('kagami-plugin-')) {
+                try {
+                    const pkgPath = path.join(nodeModules, dir);
+                    const PluginModule = require(pkgPath);
+                    const plugin = instantiatePlugin(PluginModule);
+                    if (plugin) {
+                        plugins[plugin.key] = plugin;
+                    }
+                }
+                catch (e) {
+                    console.warn(`Failed to load plugin ${dir}:`, e);
+                }
+            }
+        }
+        return plugins;
+    });
+}
+function installPlugin(sourceName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (sourceName.startsWith('.') || path.isAbsolute(sourceName)) {
+            if (!fs.existsSync(sourceName)) {
+                console.error(`Path not found: ${sourceName}`);
+                return;
+            }
+            try {
+                yield execAsync(`npm install ${sourceName}`);
+                console.log(`✓ Installed from ${sourceName}`);
+                return;
+            }
+            catch (e) {
+                console.error(`Failed to install from path:`, e.message);
+                return;
+            }
+        }
+        const candidates = [
+            `@kagami/plugin-${sourceName}`,
+            `kagami-plugin-${sourceName}`
+        ];
+        for (const pkg of candidates) {
+            try {
+                yield execAsync(`npm view ${pkg}`);
+                console.log(`Installing ${pkg}...`);
+                yield execAsync(`npm install ${pkg}`);
+                console.log(`✓ Installed ${pkg}`);
+                return;
+            }
+            catch (_a) {
+                continue;
+            }
+        }
+        console.error(`Plugin "${sourceName}" not found. Tried:`);
+        for (const pkg of candidates) {
+            console.error(`  - ${pkg}`);
+        }
+        console.error(`\nFor local plugins, use: kagami install <path>`);
+    });
+}

package/dist/search.d.ts

@@ -0,0 +1,4 @@
+import { IManga, IPlugin } from "@kagami/plugin";
+export declare function prepareManga(manga: IManga, plugin: IPlugin, writeStatus?: (msg: string) => void): Promise<void>;
+export declare function searchManga(query: string, sources: string[], plugins: Record<string, IPlugin>): Promise<Array<IManga>>;
+//# sourceMappingURL=search.d.ts.map

package/dist/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAsB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CA2CrH;AAED,wBAAsB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAwC1H"}

package/dist/search.js

@@ -0,0 +1,101 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareManga = prepareManga;
+exports.searchManga = searchManga;
+function prepareManga(manga, plugin, writeStatus) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const status = writeStatus || ((msg) => { });
+        const mangaName = Array.isArray(manga.name) ? manga.name[0] : manga.name;
+        // Fetch detailed manga info
+        status(`| \x1b[33m${mangaName}\x1b[0m: fetching info...`);
+        try {
+            const info = yield plugin.getMangaInfo(String(manga.id));
+            if (info) {
+                if (info.author)
+                    manga.author = info.author;
+                if (info.status)
+                    manga.status = info.status;
+                if (info.year)
+                    manga.year = info.year;
+                if (info.covers)
+                    manga.covers = info.covers;
+            }
+        }
+        catch (err) {
+            // Ignore errors for optional info
+        }
+        // Fetch covers (via separate API)
+        try {
+            const covers = yield plugin.getMangaCovers(manga);
+            if (covers && covers.length > 0) {
+                manga.covers = covers;
+            }
+        }
+        catch (err) {
+            // Ignore errors for optional covers
+        }
+        // Fetch chapters
+        status(`| \x1b[33m${mangaName}\x1b[0m: fetching chapters...`);
+        try {
+            const chapters = yield plugin.getChapters(manga);
+            manga.chapters = chapters.length;
+            status(`| \x1b[33m${mangaName}\x1b[0m: \x1b[32m${chapters.length} ✓\x1b[0m`);
+        }
+        catch (err) {
+            const error = err;
+            manga.chapters = undefined;
+            status(`| \x1b[33m${mangaName}\x1b[0m: \x1b[31m? (error)\x1b[0m`);
+            if (err instanceof SyntaxError) {
+                console.error(`\n  Error: Invalid response from ${manga.source} - possible 403/404/network error`);
+            }
+        }
+        yield plugin.delay();
+    });
+}
+function searchManga(query, sources, plugins) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allResults = [];
+        let totalResults = 0;
+        const writeStatus = (msg) => {
+            process.stdout.write(`\r\x1b[2K${msg}`);
+        };
+        writeStatus(`Searching for "${query}"...`);
+        for (const source of sources) {
+            const plugin = plugins[source];
+            try {
+                writeStatus(`[\x1b[32m${source}\x1b[0m: searching...`);
+                const results = yield plugin.search(query);
+                writeStatus(`[\x1b[32m${source}\x1b[0m: ${results.length} found`);
+                for (let i = 0; i < results.length; i++) {
+                    const manga = results[i];
+                    yield prepareManga(manga, plugin, (msg) => {
+                        const mangaName = Array.isArray(manga.name) ? manga.name[0] : manga.name;
+                        writeStatus(`[\x1b[32m${source}\x1b[0m: ${results.length} found ${msg}`);
+                    });
+                }
+                allResults.push(...results);
+                totalResults += results.length;
+                writeStatus(`[\x1b[32m${source}\x1b[0m: ${results.length} found]`);
+                yield plugin.delay();
+            }
+            catch (err) {
+                const error = err;
+                writeStatus(`[\x1b[31m${source}\x1b[0m: error - ${error.message || err}]`);
+                if (err instanceof SyntaxError) {
+                    console.error(`\n  (Invalid JSON response from ${source} - possible 403/404/network error)`);
+                }
+            }
+        }
+        process.stdout.write(`\nFound ${totalResults} results total\n\n`);
+        return allResults;
+    });
+}

package/dist/ui.d.ts

@@ -0,0 +1,5 @@
+import { IManga, IPlugin } from '@kagami/plugin';
+export declare function selectSources(availableSources: string[]): Promise<string[]>;
+export declare function selectManga(results: Array<IManga>, plugins: Record<string, IPlugin>): Promise<IManga[]>;
+export declare function confirmDownload(manga: IManga): Promise<boolean>;
+//# sourceMappingURL=ui.d.ts.map

package/dist/ui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.d.ts","sourceRoot":"","sources":["../src/ui.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAsB,aAAa,CAAC,gBAAgB,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAajF;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA8B7G;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CASrE"}

package/dist/ui.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectSources = selectSources;
+exports.selectManga = selectManga;
+exports.confirmDownload = confirmDownload;
+const inquirer_1 = __importDefault(require("inquirer"));
+function selectSources(availableSources) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const answer = yield inquirer_1.default.prompt({
+            type: 'checkbox',
+            name: 'sources',
+            message: 'Select sources to search:',
+            choices: availableSources.map(key => ({
+                name: key,
+                value: key,
+                checked: true
+            }))
+        });
+        return answer.sources;
+    });
+}
+function selectManga(results, plugins) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (results.length === 0) {
+            console.log('No results found.');
+            return [];
+        }
+        const answer = yield inquirer_1.default.prompt({
+            type: 'checkbox',
+            name: 'selected',
+            message: 'Select manga to download:',
+            pageSize: process.stdout.rows - 4 || 20,
+            choices: results.map((manga, idx) => {
+                var _a;
+                const name = Array.isArray(manga.name) ? manga.name[0] : manga.name;
+                const chapterCount = (_a = manga.chapters) !== null && _a !== void 0 ? _a : '?';
+                return {
+                    name: `${idx + 1}. [${manga.source}] ${name} (${chapterCount} chapters)`,
+                    value: manga,
+                    short: name
+                };
+            }),
+            validate: (answers) => {
+                if (answers.length === 0) {
+                    return 'Please select at least one manga';
+                }
+                return true;
+            }
+        });
+        return answer.selected;
+    });
+}
+function confirmDownload(manga) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const name = Array.isArray(manga.name) ? manga.name[0] : manga.name;
+        const answer = yield inquirer_1.default.prompt({
+            type: 'confirm',
+            name: 'confirmed',
+            message: `Download "${name}" from ${manga.source}?`,
+            default: true
+        });
+        return answer.confirmed;
+    });
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "kagami-cli",
+  "version": "0.1.0",
+  "description": "CLI for kagami",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "kagami": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --build",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": ["manga", "parser", "cli", "kagami"],
+  "author": "Ilya Tovstenok <iliya.tovstyonok@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iliyat/kagami.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/iliyat/kagami#readme",
+  "dependencies": {
+    "@kagami-cli/plugin": "^0.1.0",
+    "cli-progress": "^3.12.0",
+    "command-line-args": "^6.0.1",
+    "command-line-usage": "^7.0.4",
+    "inquirer": "^13.4.2"
+  },
+  "devDependencies": {
+    "@types/cli-progress": "^3.11.6",
+    "@types/command-line-args": "^5.2.3",
+    "@types/command-line-usage": "^5.0.4",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.4.0",
+    "typescript": "^5.5.3"
+  }
+}