mediaguru 1.0.0

package/dist/cli/interactive.js

@@ -0,0 +1,647 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs';
+import { printHeader, printFooter } from '../utils/branding.js';
+import { PdfEngine } from '../core/pdf/index.js';
+import { ImageEngine } from '../core/image/index.js';
+import { QrEngine } from '../core/qr/index.js';
+import { OcrEngine } from '../core/ocr/index.js';
+import { ScreenshotEngine } from '../core/screenshot/index.js';
+import { Text2ImgEngine } from '../core/text2img/index.js';
+import { CompressEngine } from '../core/compress/index.js';
+import { ConfigManager } from '../core/config/index.js';
+import { formatBytes } from '../utils/file.js';
+import { RestApiServer } from '../core/server/index.js';
+export async function launchInteractive() {
+    let exiting = false;
+    while (!exiting) {
+        printHeader();
+        const { choice } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'choice',
+                message: 'Welcome to MediaGuru. Select a processing tool:',
+                choices: [
+                    { name: '1. 📄 PDF Tools', value: 'pdf' },
+                    { name: '2. 🖼️ Image Tools', value: 'image' },
+                    { name: '3. 👁️ OCR Engine', value: 'ocr' },
+                    { name: '4. 🔗 QR Generator', value: 'qr' },
+                    { name: '5. 🌐 Website Screenshot', value: 'screenshot' },
+                    { name: '6. 🎨 Text-to-Image (Social Card)', value: 'text2img' },
+                    { name: '7. 📦 Compression', value: 'compress' },
+                    { name: '8. 🌐 Launch REST API Server', value: 'server' },
+                    { name: '9. ⚙️ Configuration', value: 'config' },
+                    { name: '10. ❌ Exit', value: 'exit' },
+                ],
+            },
+        ]);
+        switch (choice) {
+            case 'pdf':
+                await handlePdfMenu();
+                break;
+            case 'image':
+                await handleImageMenu();
+                break;
+            case 'ocr':
+                await handleOcrMenu();
+                break;
+            case 'qr':
+                await handleQrMenu();
+                break;
+            case 'screenshot':
+                await handleScreenshotMenu();
+                break;
+            case 'text2img':
+                await handleText2ImgMenu();
+                break;
+            case 'compress':
+                await handleCompressMenu();
+                break;
+            case 'server':
+                await handleServerMenu();
+                break;
+            case 'config':
+                await handleConfigMenu();
+                break;
+            case 'exit':
+                exiting = true;
+                break;
+        }
+        if (!exiting) {
+            console.log('\n');
+            await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'continue',
+                    message: 'Press ENTER to return to the main menu...',
+                },
+            ]);
+        }
+    }
+    printHeader();
+    console.log(chalk.green.bold('\nThank you for using MediaGuru! Have a wonderful day! ✨'));
+    printFooter();
+}
+async function handlePdfMenu() {
+    const { action } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: 'Select a PDF tool operation:',
+            choices: [
+                { name: 'Markdown to PDF', value: 'md2pdf' },
+                { name: 'HTML to PDF', value: 'html2pdf' },
+                { name: 'Merge PDFs', value: 'merge' },
+                { name: 'Split PDF', value: 'split' },
+                { name: 'Extract Text', value: 'extract' },
+                { name: 'Compress PDF', value: 'compress' },
+                { name: '← Back to Main Menu', value: 'back' },
+            ],
+        },
+    ]);
+    if (action === 'back')
+        return;
+    if (action === 'md2pdf') {
+        const { path: mdPath } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'path',
+                message: 'Enter path to Markdown file:',
+                validate: (input) => fs.existsSync(input) ? true : 'File does not exist.',
+            },
+        ]);
+        const spinner = ora('Converting Markdown to PDF...').start();
+        try {
+            const out = await PdfEngine.markdownToPdf(mdPath);
+            spinner.succeed(`PDF created successfully: ${chalk.cyan(out)}`);
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+    else if (action === 'html2pdf') {
+        const { path: htmlPath } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'path',
+                message: 'Enter path to HTML file:',
+                validate: (input) => fs.existsSync(input) ? true : 'File does not exist.',
+            },
+        ]);
+        const spinner = ora('Converting HTML to PDF...').start();
+        try {
+            const out = await PdfEngine.htmlToPdf(htmlPath);
+            spinner.succeed(`PDF created successfully: ${chalk.cyan(out)}`);
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+    else if (action === 'merge') {
+        const { list } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'list',
+                message: 'Enter PDF file paths to merge (comma separated):',
+                validate: (input) => {
+                    const files = input.split(',').map((f) => f.trim());
+                    if (files.length < 2)
+                        return 'Please specify at least 2 files.';
+                    for (const f of files) {
+                        if (!fs.existsSync(f))
+                            return `File does not exist: ${f}`;
+                    }
+                    return true;
+                },
+            },
+        ]);
+        const files = list.split(',').map((f) => f.trim());
+        const spinner = ora('Merging PDFs...').start();
+        try {
+            const out = await PdfEngine.merge(files);
+            spinner.succeed(`PDFs merged successfully: ${chalk.cyan(out)}`);
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+    else if (action === 'split') {
+        const { path: pdfPath } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'path',
+                message: 'Enter path to PDF file:',
+                validate: (input) => fs.existsSync(input) ? true : 'File does not exist.',
+            },
+        ]);
+        const spinner = ora('Splitting PDF pages...').start();
+        try {
+            const pages = await PdfEngine.split(pdfPath);
+            spinner.succeed(`Split into ${pages.length} pages:`);
+            pages.forEach((p) => console.log(`  - ${chalk.cyan(p)}`));
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+    else if (action === 'extract') {
+        const { path: pdfPath } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'path',
+                message: 'Enter path to PDF file:',
+                validate: (input) => fs.existsSync(input) ? true : 'File does not exist.',
+            },
+        ]);
+        const spinner = ora('Extracting PDF text...').start();
+        try {
+            const text = await PdfEngine.extractText(pdfPath);
+            spinner.succeed('Extraction completed. Text Preview:');
+            console.log(chalk.dim('\n' + '─'.repeat(40)));
+            console.log(text.substring(0, 1000) + (text.length > 1000 ? '\n...[truncated]' : ''));
+            console.log(chalk.dim('─'.repeat(40)));
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+    else if (action === 'compress') {
+        const { path: pdfPath } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'path',
+                message: 'Enter path to PDF file:',
+                validate: (input) => fs.existsSync(input) ? true : 'File does not exist.',
+            },
+        ]);
+        const spinner = ora('Optimizing and compressing PDF...').start();
+        try {
+            const out = await PdfEngine.compress(pdfPath);
+            spinner.succeed(`PDF compressed successfully: ${chalk.cyan(out)}`);
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+}
+async function handleImageMenu() {
+    const { action } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: 'Select an Image tool operation:',
+            choices: [
+                { name: 'Resize Image', value: 'resize' },
+                { name: 'Convert Format', value: 'convert' },
+                { name: 'Overlay Watermark', value: 'watermark' },
+                { name: 'Remove Background', value: 'remove-bg' },
+                { name: '← Back to Main Menu', value: 'back' },
+            ],
+        },
+    ]);
+    if (action === 'back')
+        return;
+    const { path: imgPath } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'path',
+            message: 'Enter image file path:',
+            validate: (input) => fs.existsSync(input) ? true : 'File does not exist.',
+        },
+    ]);
+    if (action === 'resize') {
+        const { size } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'size',
+                message: 'Enter target size (e.g. 800x600 or 800):',
+                default: '800x600',
+            },
+        ]);
+        const spinner = ora('Resizing image...').start();
+        try {
+            const out = await ImageEngine.resize(imgPath, size);
+            spinner.succeed(`Resized image saved: ${chalk.cyan(out)}`);
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+    else if (action === 'convert') {
+        const { format } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'format',
+                message: 'Select target format:',
+                choices: ['webp', 'png', 'jpg', 'jpeg'],
+            },
+        ]);
+        const spinner = ora('Converting format...').start();
+        try {
+            const out = await ImageEngine.convert(imgPath, format);
+            spinner.succeed(`Converted image saved: ${chalk.cyan(out)}`);
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+    else if (action === 'watermark') {
+        const { wmPath } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'wmPath',
+                message: 'Enter path to Watermark logo/image:',
+                validate: (input) => fs.existsSync(input) ? true : 'File does not exist.',
+            },
+        ]);
+        const spinner = ora('Overlaying watermark...').start();
+        try {
+            const out = await ImageEngine.watermark(imgPath, wmPath);
+            spinner.succeed(`Watermarked image saved: ${chalk.cyan(out)}`);
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+    else if (action === 'remove-bg') {
+        const { engine } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'engine',
+                message: 'Select background removal engine:',
+                choices: [
+                    { name: 'Local (Color chroma thresholding)', value: 'local' },
+                    { name: 'API (remove.bg - needs API key)', value: 'api' },
+                ],
+            },
+        ]);
+        const spinner = ora('Extracting and removing background...').start();
+        try {
+            const out = await ImageEngine.removeBg(imgPath, engine);
+            spinner.succeed(`Background removed. Image saved: ${chalk.cyan(out)}`);
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+}
+async function handleOcrMenu() {
+    const { path: imgPath } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'path',
+            message: 'Enter image file path for OCR:',
+            validate: (input) => fs.existsSync(input) ? true : 'File does not exist.',
+        },
+    ]);
+    const { format } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'format',
+            message: 'Export text to file format?',
+            choices: [
+                { name: 'None (Console only)', value: 'none' },
+                { name: 'Text file (.txt)', value: 'txt' },
+                { name: 'Markdown file (.md)', value: 'markdown' },
+                { name: 'Structured JSON (.json)', value: 'json' },
+            ],
+        },
+    ]);
+    const spinner = ora('Parsing text from image (running OCR)...').start();
+    try {
+        const exportOpt = format === 'none' ? undefined : format;
+        const res = await OcrEngine.extract(imgPath, { exportFormat: exportOpt });
+        spinner.succeed('OCR Process Completed!');
+        console.log(chalk.yellow.bold('\nExtracted Text:'));
+        console.log(chalk.dim('─'.repeat(40)));
+        console.log(res.text.trim());
+        console.log(chalk.dim('─'.repeat(40)));
+        if (res.exportedPath) {
+            console.log(chalk.green(`\nExported file: ${chalk.bold(res.exportedPath)}`));
+        }
+    }
+    catch (e) {
+        spinner.fail(`OCR Failed: ${e.message}`);
+    }
+}
+async function handleQrMenu() {
+    const { text } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'text',
+            message: 'Enter URL or Text to encode in QR:',
+            default: 'https://kontyra.com',
+        },
+    ]);
+    const { svg } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'svg',
+            message: 'Generate vector SVG instead of binary PNG?',
+            default: false,
+        },
+    ]);
+    const { size } = await inquirer.prompt([
+        {
+            type: 'number',
+            name: 'size',
+            message: 'Enter square size in pixels:',
+            default: 300,
+        },
+    ]);
+    const spinner = ora('Generating QR Code...').start();
+    try {
+        const out = await QrEngine.generate(text, { svg, size });
+        spinner.succeed(`QR Code generated: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Failed: ${e.message}`);
+    }
+}
+async function handleScreenshotMenu() {
+    const { url } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'url',
+            message: 'Enter website URL to screenshot:',
+            default: 'https://example.com',
+        },
+    ]);
+    const { fullPage } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'fullPage',
+            message: 'Capture full scrollable page?',
+            default: false,
+        },
+    ]);
+    const { mobile } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'mobile',
+            message: 'Emulate responsive mobile viewport?',
+            default: false,
+        },
+    ]);
+    const spinner = ora('Launching browser and rendering website screenshot...').start();
+    try {
+        const out = await ScreenshotEngine.capture(url, { fullPage, mobile });
+        spinner.succeed(`Screenshot saved: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Failed: ${e.message}`);
+    }
+}
+async function handleText2ImgMenu() {
+    const { text } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'text',
+            message: 'Enter message/quote for the social card:',
+            default: 'Welcome to Kontyra',
+        },
+    ]);
+    const { type } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'type',
+            message: 'Select card template type:',
+            choices: [
+                { name: 'Social Post Card (1200x630)', value: 'social' },
+                { name: 'Quote Block (800x800)', value: 'quote' },
+                { name: 'Announcements Poster (800x1200)', value: 'poster' },
+                { name: 'Header Banner (1200x400)', value: 'banner' },
+            ],
+        },
+    ]);
+    const { theme } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'theme',
+            message: 'Select visual color theme:',
+            choices: [
+                { name: 'Dark Mode (Radial slate gradient)', value: 'dark' },
+                { name: 'Light Mode (Linear soft blue gradient)', value: 'light' },
+                { name: 'Glassmorphic (Airy pastel blurred canvas)', value: 'glass' },
+            ],
+        },
+    ]);
+    const { title } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'title',
+            message: 'Enter category/title label (optional):',
+            default: '',
+        },
+    ]);
+    const { author } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'author',
+            message: 'Enter author name label (optional):',
+            default: '',
+        },
+    ]);
+    const spinner = ora('Compiling card design in browser...').start();
+    try {
+        const out = await Text2ImgEngine.generate(text, {
+            type,
+            theme,
+            title,
+            author,
+        });
+        spinner.succeed(`Social card exported: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Failed: ${e.message}`);
+    }
+}
+async function handleCompressMenu() {
+    const { type } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'type',
+            message: 'What would you like to compress?',
+            choices: [
+                { name: 'Single image file', value: 'file' },
+                { name: 'Entire folder recursively', value: 'folder' },
+            ],
+        },
+    ]);
+    if (type === 'file') {
+        const { path: fileP } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'path',
+                message: 'Enter image file path:',
+                validate: (input) => fs.existsSync(input) ? true : 'File does not exist.',
+            },
+        ]);
+        const spinner = ora('Compressing image...').start();
+        try {
+            const res = await CompressEngine.compressImage(fileP);
+            spinner.succeed(`Compressed image saved: ${chalk.cyan(res.filePath)}`);
+            console.log(chalk.bold.yellow('\nCompression Report:'));
+            console.log(`- Original size: ${chalk.bold(formatBytes(res.originalSize))}`);
+            console.log(`- Compressed size: ${chalk.bold(formatBytes(res.compressedSize))}`);
+            console.log(`- Space saved: ${chalk.green.bold(formatBytes(res.savedBytes))} (${chalk.green.bold(res.percentage.toFixed(1))}% reduction)`);
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+    else {
+        const { path: folderP } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'path',
+                message: 'Enter folder path:',
+                validate: (input) => fs.existsSync(input) && fs.statSync(input).isDirectory() ? true : 'Folder does not exist.',
+            },
+        ]);
+        const spinner = ora('Compressing entire folder recursively...').start();
+        try {
+            const results = await CompressEngine.compressFolder(folderP);
+            spinner.succeed(`Folder compressed. Total files processed: ${results.length}`);
+            if (results.length > 0) {
+                let totalOriginal = 0;
+                let totalCompressed = 0;
+                results.forEach((r) => {
+                    totalOriginal += r.originalSize;
+                    totalCompressed += r.compressedSize;
+                });
+                const totalSaved = totalOriginal - totalCompressed;
+                const totalPct = totalOriginal > 0 ? (totalSaved / totalOriginal) * 100 : 0;
+                console.log(chalk.bold.yellow('\nBatch Folder Compression Report:'));
+                console.log(`- Processed files: ${chalk.cyan(results.length)}`);
+                console.log(`- Combined original size: ${chalk.bold(formatBytes(totalOriginal))}`);
+                console.log(`- Combined compressed size: ${chalk.bold(formatBytes(totalCompressed))}`);
+                console.log(`- Combined space saved: ${chalk.green.bold(formatBytes(totalSaved))} (${chalk.green.bold(totalPct.toFixed(1))}% reduction)`);
+            }
+        }
+        catch (e) {
+            spinner.fail(`Failed: ${e.message}`);
+        }
+    }
+}
+async function handleConfigMenu() {
+    const current = ConfigManager.load();
+    console.log(chalk.bold.yellow('\nCurrent Configuration:'));
+    console.log(`1. Default Image Format: ${chalk.cyan(current.defaultImageFormat)}`);
+    console.log(`2. PDF Rendering Engine: ${chalk.cyan(current.pdfEngine)}`);
+    console.log(`3. Compression Quality: ${chalk.cyan(current.compressionQuality + '%')}`);
+    console.log(`4. Screenshot Resolution: ${chalk.cyan(current.screenshotResolution)}`);
+    console.log(`5. Default Output Folder: ${chalk.cyan(current.outputFolder)}`);
+    console.log('\n');
+    const { edit } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'edit',
+            message: 'Would you like to edit any settings?',
+            default: false,
+        },
+    ]);
+    if (!edit)
+        return;
+    const answers = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'defaultImageFormat',
+            message: 'Select default image format:',
+            choices: ['webp', 'png', 'jpg', 'jpeg'],
+            default: current.defaultImageFormat,
+        },
+        {
+            type: 'list',
+            name: 'pdfEngine',
+            message: 'Select PDF engine:',
+            choices: ['playwright', 'local'],
+            default: current.pdfEngine,
+        },
+        {
+            type: 'number',
+            name: 'compressionQuality',
+            message: 'Enter image compression quality (1-100):',
+            default: current.compressionQuality,
+            validate: (val) => val >= 1 && val <= 100 ? true : 'Must be between 1 and 100.',
+        },
+        {
+            type: 'input',
+            name: 'screenshotResolution',
+            message: 'Enter screenshot resolution width x height:',
+            default: current.screenshotResolution,
+            validate: (input) => input.includes('x') ? true : 'Must be format like "1280x720".',
+        },
+        {
+            type: 'input',
+            name: 'outputFolder',
+            message: 'Enter default output directory path:',
+            default: current.outputFolder,
+        },
+    ]);
+    ConfigManager.update(answers);
+    console.log(chalk.green.bold('\nSettings updated successfully!'));
+}
+async function handleServerMenu() {
+    const { port } = await inquirer.prompt([
+        {
+            type: 'number',
+            name: 'port',
+            message: 'Enter port to launch REST API server on:',
+            default: 3000,
+            validate: (val) => val > 0 && val <= 65535 ? true : 'Please enter a valid port.',
+        },
+    ]);
+    const server = new RestApiServer();
+    try {
+        await server.start(port);
+        console.log(chalk.yellow('\n[REST Server] Running in foreground...'));
+        console.log(chalk.bold.red('Press Ctrl+C to terminate the server and exit MediaGuru.'));
+        // Hang process to run server
+        await new Promise(() => { });
+    }
+    catch (e) {
+        console.error(chalk.red(`Server failed to start: ${e.message}`));
+    }
+}

package/dist/core/batch/index.d.ts

@@ -0,0 +1,16 @@
+export interface BatchResult {
+    sourceFile: string;
+    outputFile?: string;
+    success: boolean;
+    error?: string;
+}
+export declare class BatchEngine {
+    /**
+     * Run batch conversion on images matching a glob pattern
+     */
+    static convertImages(pattern: string, targetFormat: string): Promise<BatchResult[]>;
+    /**
+     * Run batch PDF generation on markdown or HTML files matching a glob pattern
+     */
+    static convertToPdf(pattern: string): Promise<BatchResult[]>;
+}