mediaguru 1.0.0

package/dist/core/batch/index.js

@@ -0,0 +1,66 @@
+import { glob } from 'glob';
+import path from 'path';
+import { ImageEngine } from '../image/index.js';
+import { PdfEngine } from '../pdf/index.js';
+export class BatchEngine {
+    /**
+     * Run batch conversion on images matching a glob pattern
+     */
+    static async convertImages(pattern, targetFormat) {
+        const files = await glob(pattern, { windowsPathsNoEscape: true });
+        const results = [];
+        for (const file of files) {
+            try {
+                const outPath = await ImageEngine.convert(file, targetFormat);
+                results.push({
+                    sourceFile: file,
+                    outputFile: outPath,
+                    success: true,
+                });
+            }
+            catch (err) {
+                results.push({
+                    sourceFile: file,
+                    success: false,
+                    error: err.message || String(err),
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Run batch PDF generation on markdown or HTML files matching a glob pattern
+     */
+    static async convertToPdf(pattern) {
+        const files = await glob(pattern, { windowsPathsNoEscape: true });
+        const results = [];
+        for (const file of files) {
+            const ext = path.extname(file).toLowerCase();
+            try {
+                let outPath = '';
+                if (ext === '.md') {
+                    outPath = await PdfEngine.markdownToPdf(file);
+                }
+                else if (ext === '.html' || ext === '.htm') {
+                    outPath = await PdfEngine.htmlToPdf(file);
+                }
+                else {
+                    throw new Error(`Unsupported extension for PDF generation: ${ext}`);
+                }
+                results.push({
+                    sourceFile: file,
+                    outputFile: outPath,
+                    success: true,
+                });
+            }
+            catch (err) {
+                results.push({
+                    sourceFile: file,
+                    success: false,
+                    error: err.message || String(err),
+                });
+            }
+        }
+        return results;
+    }
+}

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

@@ -0,0 +1,17 @@
+export interface CompressionResult {
+    filePath: string;
+    originalSize: number;
+    compressedSize: number;
+    savedBytes: number;
+    percentage: number;
+}
+export declare class CompressEngine {
+    /**
+     * Compresses a single image and returns statistics
+     */
+    static compressImage(imagePath: string, outputPath?: string): Promise<CompressionResult>;
+    /**
+     * Compresses all images in a folder recursively
+     */
+    static compressFolder(folderPath: string, outputDir?: string): Promise<CompressionResult[]>;
+}

package/dist/core/compress/index.js

@@ -0,0 +1,96 @@
+import fs from 'fs';
+import path from 'path';
+import sharp from 'sharp';
+import { ConfigManager } from '../config/index.js';
+export class CompressEngine {
+    /**
+     * Compresses a single image and returns statistics
+     */
+    static async compressImage(imagePath, outputPath) {
+        const config = ConfigManager.load();
+        const quality = config.compressionQuality;
+        const outDir = ConfigManager.getOutputFolder();
+        const originalStats = fs.statSync(imagePath);
+        const originalSize = originalStats.size;
+        const ext = path.extname(imagePath).toLowerCase();
+        const baseName = path.basename(imagePath);
+        const targetPath = outputPath || path.join(outDir, `compressed_${baseName}`);
+        // Ensure output dir exists
+        if (!fs.existsSync(path.dirname(targetPath))) {
+            fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        }
+        let pipe = sharp(imagePath);
+        if (ext === '.jpg' || ext === '.jpeg') {
+            pipe = pipe.jpeg({ quality, progressive: true });
+        }
+        else if (ext === '.png') {
+            pipe = pipe.png({ quality, compressionLevel: 9, palette: true });
+        }
+        else if (ext === '.webp') {
+            pipe = pipe.webp({ quality, effort: 6 });
+        }
+        else {
+            // For unsupported image types, copy directly
+            fs.copyFileSync(imagePath, targetPath);
+            return {
+                filePath: targetPath,
+                originalSize,
+                compressedSize: originalSize,
+                savedBytes: 0,
+                percentage: 0,
+            };
+        }
+        await pipe.toFile(targetPath);
+        const compressedStats = fs.statSync(targetPath);
+        const compressedSize = compressedStats.size;
+        const savedBytes = originalSize - compressedSize;
+        const percentage = originalSize > 0 ? (savedBytes / originalSize) * 100 : 0;
+        return {
+            filePath: targetPath,
+            originalSize,
+            compressedSize,
+            savedBytes,
+            percentage,
+        };
+    }
+    /**
+     * Compresses all images in a folder recursively
+     */
+    static async compressFolder(folderPath, outputDir) {
+        const targetDir = outputDir || path.join(ConfigManager.getOutputFolder(), 'compressed_folder');
+        const results = [];
+        const supportedExts = ['.png', '.jpg', '.jpeg', '.webp'];
+        async function walk(dir, currentDest) {
+            if (!fs.existsSync(currentDest)) {
+                fs.mkdirSync(currentDest, { recursive: true });
+            }
+            const files = fs.readdirSync(dir);
+            for (const file of files) {
+                const fullPath = path.join(dir, file);
+                const destPath = path.join(currentDest, file);
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    await walk(fullPath, destPath);
+                }
+                else {
+                    const ext = path.extname(file).toLowerCase();
+                    if (supportedExts.includes(ext)) {
+                        try {
+                            const res = await CompressEngine.compressImage(fullPath, destPath);
+                            results.push(res);
+                        }
+                        catch (err) {
+                            console.error(`Failed to compress ${file}:`, err);
+                        }
+                    }
+                    else {
+                        // Non-image files are copied over to maintain folder integrity
+                        fs.copyFileSync(fullPath, destPath);
+                    }
+                }
+            }
+        }
+        await walk(folderPath, targetDir);
+        return results;
+    }
+}

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

@@ -0,0 +1,14 @@
+export interface AppConfig {
+    defaultImageFormat: 'png' | 'jpg' | 'jpeg' | 'webp' | 'svg';
+    pdfEngine: 'playwright' | 'local';
+    compressionQuality: number;
+    screenshotResolution: string;
+    outputFolder: string;
+}
+export declare class ConfigManager {
+    private static cachedConfig;
+    static load(): AppConfig;
+    static save(config: AppConfig): void;
+    static update(updates: Partial<AppConfig>): AppConfig;
+    static getOutputFolder(): string;
+}

package/dist/core/config/index.js

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const DEFAULT_CONFIG = {
+    defaultImageFormat: 'webp',
+    pdfEngine: 'playwright',
+    compressionQuality: 80,
+    screenshotResolution: '1280x720',
+    outputFolder: './output',
+};
+const CONFIG_FILE = path.join(os.homedir(), '.mediagururc.json');
+export class ConfigManager {
+    static cachedConfig = null;
+    static load() {
+        if (this.cachedConfig)
+            return this.cachedConfig;
+        try {
+            if (fs.existsSync(CONFIG_FILE)) {
+                const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+                const parsed = JSON.parse(data);
+                this.cachedConfig = { ...DEFAULT_CONFIG, ...parsed };
+            }
+            else {
+                this.cachedConfig = { ...DEFAULT_CONFIG };
+                this.save(this.cachedConfig);
+            }
+        }
+        catch (e) {
+            this.cachedConfig = { ...DEFAULT_CONFIG };
+        }
+        return this.cachedConfig || DEFAULT_CONFIG;
+    }
+    static save(config) {
+        try {
+            fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+            this.cachedConfig = config;
+        }
+        catch (e) {
+            console.error('Failed to save config file:', e);
+        }
+    }
+    static update(updates) {
+        const current = this.load();
+        const updated = { ...current, ...updates };
+        this.save(updated);
+        return updated;
+    }
+    static getOutputFolder() {
+        const config = this.load();
+        const folder = config.outputFolder;
+        if (!fs.existsSync(folder)) {
+            fs.mkdirSync(folder, { recursive: true });
+        }
+        return folder;
+    }
+}

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

@@ -0,0 +1,12 @@
+export declare class ExportEngine {
+    /**
+     * Exports the current configuration in the specified format
+     */
+    static exportConfig(format: 'json' | 'markdown' | 'csv', opts?: {
+        outputPath?: string;
+    }): Promise<string>;
+    /**
+     * Generically converts a JSON file containing an array of objects to CSV or Markdown
+     */
+    static convertJsonData(jsonFilePath: string, format: 'csv' | 'markdown', outputPath?: string): Promise<string>;
+}

package/dist/core/export/index.js

@@ -0,0 +1,82 @@
+import fs from 'fs';
+import path from 'path';
+import { createObjectCsvWriter } from 'csv-writer';
+import { ConfigManager } from '../config/index.js';
+export class ExportEngine {
+    /**
+     * Exports the current configuration in the specified format
+     */
+    static async exportConfig(format, opts = {}) {
+        const config = ConfigManager.load();
+        const outDir = ConfigManager.getOutputFolder();
+        const targetPath = opts.outputPath || path.join(outDir, `mediaguru_config.${format}`);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        if (format === 'json') {
+            fs.writeFileSync(targetPath, JSON.stringify(config, null, 2), 'utf-8');
+        }
+        else if (format === 'markdown') {
+            const md = `# MediaGuru Configuration Export\n\n` +
+                `| Setting | Value |\n` +
+                `| --- | --- |\n` +
+                `| **Default Image Format** | \`${config.defaultImageFormat}\` |\n` +
+                `| **PDF Engine** | \`${config.pdfEngine}\` |\n` +
+                `| **Compression Quality** | \`${config.compressionQuality}%\` |\n` +
+                `| **Screenshot Resolution** | \`${config.screenshotResolution}\` |\n` +
+                `| **Output Folder** | \`${config.outputFolder}\` |\n` +
+                `\n*Generated by MediaGuru*\n`;
+            fs.writeFileSync(targetPath, md, 'utf-8');
+        }
+        else {
+            // CSV
+            const csvWriter = createObjectCsvWriter({
+                path: targetPath,
+                header: [
+                    { id: 'setting', title: 'Setting' },
+                    { id: 'value', title: 'Value' },
+                ],
+            });
+            const records = Object.entries(config).map(([key, val]) => ({
+                setting: key,
+                value: String(val),
+            }));
+            await csvWriter.writeRecords(records);
+        }
+        return targetPath;
+    }
+    /**
+     * Generically converts a JSON file containing an array of objects to CSV or Markdown
+     */
+    static async convertJsonData(jsonFilePath, format, outputPath) {
+        const rawData = fs.readFileSync(jsonFilePath, 'utf-8');
+        const data = JSON.parse(rawData);
+        const items = Array.isArray(data) ? data : [data];
+        if (items.length === 0) {
+            throw new Error('JSON data contains no objects to export.');
+        }
+        const outDir = ConfigManager.getOutputFolder();
+        const baseName = path.basename(jsonFilePath, path.extname(jsonFilePath));
+        const targetPath = outputPath || path.join(outDir, `${baseName}_converted.${format}`);
+        if (format === 'markdown') {
+            const keys = Object.keys(items[0]);
+            let md = `\n| ${keys.join(' | ')} |\n`;
+            md += `| ${keys.map(() => '---').join(' | ')} |\n`;
+            for (const item of items) {
+                const row = keys.map(k => String(item[k] !== undefined ? item[k] : ''));
+                md += `| ${row.join(' | ')} |\n`;
+            }
+            fs.writeFileSync(targetPath, md, 'utf-8');
+        }
+        else {
+            // CSV
+            const keys = Object.keys(items[0]);
+            const csvWriter = createObjectCsvWriter({
+                path: targetPath,
+                header: keys.map(k => ({ id: k, title: k })),
+            });
+            await csvWriter.writeRecords(items);
+        }
+        return targetPath;
+    }
+}

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

@@ -0,0 +1,44 @@
+export interface ImageEngineOptions {
+    outputDir?: string;
+    outputPath?: string;
+    quality?: number;
+}
+export interface IBgRemovalEngine {
+    removeBackground(inputPath: string, outputPath: string): Promise<void>;
+}
+/**
+ * Local background removal engine:
+ * Uses color-threshold masking to remove solid/near-solid backdrops (chroma keying)
+ * using sharp's pixel manipulation or simple masks.
+ */
+export declare class LocalBgRemovalEngine implements IBgRemovalEngine {
+    removeBackground(inputPath: string, outputPath: string): Promise<void>;
+}
+/**
+ * API-powered background removal engine:
+ * Calls remove.bg or another API endpoint with standard multipart form upload.
+ */
+export declare class ApiBgRemovalEngine implements IBgRemovalEngine {
+    private apiKey;
+    private apiEndpoint;
+    constructor(apiKey?: string, endpoint?: string);
+    removeBackground(inputPath: string, outputPath: string): Promise<void>;
+}
+export declare class ImageEngine {
+    /**
+     * Resizes an image file
+     */
+    static resize(imagePath: string, sizeStr: string, opts?: ImageEngineOptions): Promise<string>;
+    /**
+     * Converts an image format
+     */
+    static convert(imagePath: string, format: string, opts?: ImageEngineOptions): Promise<string>;
+    /**
+     * Overlay a watermark onto an image
+     */
+    static watermark(imagePath: string, watermarkPath: string, opts?: ImageEngineOptions): Promise<string>;
+    /**
+     * Background Removal Engine runner
+     */
+    static removeBg(imagePath: string, engineType?: 'local' | 'api', opts?: ImageEngineOptions): Promise<string>;
+}

package/dist/core/image/index.js

@@ -0,0 +1,206 @@
+import fs from 'fs';
+import path from 'path';
+import sharp from 'sharp';
+import { resolveOutputPath } from '../../utils/file.js';
+import { ConfigManager } from '../config/index.js';
+/**
+ * Local background removal engine:
+ * Uses color-threshold masking to remove solid/near-solid backdrops (chroma keying)
+ * using sharp's pixel manipulation or simple masks.
+ */
+export class LocalBgRemovalEngine {
+    async removeBackground(inputPath, outputPath) {
+        // A clean, solid-backdrop color boundary removal using sharp channel extraction.
+        // It makes the dominant edge colors transparent.
+        const image = sharp(inputPath);
+        const metadata = await image.metadata();
+        if (!metadata.width || !metadata.height) {
+            throw new Error('Could not read image metadata for background removal.');
+        }
+        // Read raw pixel channels to perform chroma thresholding
+        const { data, info } = await image
+            .raw()
+            .toBuffer({ resolveWithObject: true });
+        // Let's assume the top-left pixel is the background color (common heuristic)
+        const rBg = data[0];
+        const gBg = data[1];
+        const bBg = data[2];
+        const threshold = 40; // color distance threshold
+        const transparentData = Buffer.alloc(info.width * info.height * 4);
+        let srcIdx = 0;
+        let destIdx = 0;
+        const hasAlpha = info.channels === 4;
+        for (let y = 0; y < info.height; y++) {
+            for (let x = 0; x < info.width; x++) {
+                const r = data[srcIdx];
+                const g = data[srcIdx + 1];
+                const b = data[srcIdx + 2];
+                const a = hasAlpha ? data[srcIdx + 3] : 255;
+                // Calculate Euclidean distance in RGB space
+                const distance = Math.sqrt(Math.pow(r - rBg, 2) +
+                    Math.pow(g - gBg, 2) +
+                    Math.pow(b - bBg, 2));
+                if (distance < threshold) {
+                    // Make background transparent
+                    transparentData[destIdx] = r;
+                    transparentData[destIdx + 1] = g;
+                    transparentData[destIdx + 2] = b;
+                    transparentData[destIdx + 3] = 0;
+                }
+                else {
+                    // Keep original pixel
+                    transparentData[destIdx] = r;
+                    transparentData[destIdx + 1] = g;
+                    transparentData[destIdx + 2] = b;
+                    transparentData[destIdx + 3] = a;
+                }
+                srcIdx += info.channels;
+                destIdx += 4;
+            }
+        }
+        await sharp(transparentData, {
+            raw: {
+                width: info.width,
+                height: info.height,
+                channels: 4,
+            },
+        })
+            .png()
+            .toFile(outputPath);
+    }
+}
+/**
+ * API-powered background removal engine:
+ * Calls remove.bg or another API endpoint with standard multipart form upload.
+ */
+export class ApiBgRemovalEngine {
+    apiKey;
+    apiEndpoint;
+    constructor(apiKey, endpoint) {
+        this.apiKey = apiKey || process.env.REMOVE_BG_API_KEY || '';
+        this.apiEndpoint = endpoint || 'https://api.remove.bg/v1.0/removebg';
+    }
+    async removeBackground(inputPath, outputPath) {
+        if (!this.apiKey) {
+            throw new Error('API key is not configured. Please set REMOVE_BG_API_KEY in your config or environment.');
+        }
+        const fileData = fs.readFileSync(inputPath);
+        const formData = new FormData();
+        formData.append('image_file', new Blob([fileData]), path.basename(inputPath));
+        formData.append('size', 'auto');
+        const response = await fetch(this.apiEndpoint, {
+            method: 'POST',
+            headers: {
+                'X-Api-Key': this.apiKey,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const errText = await response.text();
+            throw new Error(`remove.bg API error (${response.status}): ${errText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        fs.writeFileSync(outputPath, Buffer.from(arrayBuffer));
+    }
+}
+export class ImageEngine {
+    /**
+     * Resizes an image file
+     */
+    static async resize(imagePath, sizeStr, opts = {}) {
+        let width = null;
+        let height = null;
+        if (sizeStr.includes('x')) {
+            const parts = sizeStr.split('x');
+            width = parseInt(parts[0], 10);
+            height = parseInt(parts[1], 10);
+        }
+        else {
+            width = parseInt(sizeStr, 10);
+        }
+        if (isNaN(width) || (height !== null && isNaN(height))) {
+            throw new Error('Invalid size format. Use "800x600" or "800"');
+        }
+        const outDir = opts.outputDir || ConfigManager.getOutputFolder();
+        const config = ConfigManager.load();
+        const format = config.defaultImageFormat;
+        const targetPath = opts.outputPath || resolveOutputPath(imagePath, outDir, format, `_resized_${sizeStr}`);
+        let transformer = sharp(imagePath);
+        if (width && height) {
+            transformer = transformer.resize(width, height, { fit: 'fill' });
+        }
+        else if (width) {
+            transformer = transformer.resize(width);
+        }
+        await transformer.toFile(targetPath);
+        return targetPath;
+    }
+    /**
+     * Converts an image format
+     */
+    static async convert(imagePath, format, opts = {}) {
+        const supported = ['png', 'jpg', 'jpeg', 'webp', 'svg'];
+        const fmt = format.toLowerCase().replace('.', '');
+        if (!supported.includes(fmt)) {
+            throw new Error(`Unsupported format: ${format}. Supported are: ${supported.join(', ')}`);
+        }
+        if (fmt === 'svg') {
+            throw new Error('Converting raster images to SVG vector is not supported natively. SVG can only be converted to raster images.');
+        }
+        const outDir = opts.outputDir || ConfigManager.getOutputFolder();
+        const targetPath = opts.outputPath || resolveOutputPath(imagePath, outDir, fmt);
+        const q = opts.quality || ConfigManager.load().compressionQuality;
+        let process = sharp(imagePath);
+        if (fmt === 'png')
+            process = process.png({ quality: q });
+        else if (fmt === 'webp')
+            process = process.webp({ quality: q });
+        else if (fmt === 'jpg' || fmt === 'jpeg')
+            process = process.jpeg({ quality: q });
+        await process.toFile(targetPath);
+        return targetPath;
+    }
+    /**
+     * Overlay a watermark onto an image
+     */
+    static async watermark(imagePath, watermarkPath, opts = {}) {
+        const outDir = opts.outputDir || ConfigManager.getOutputFolder();
+        const config = ConfigManager.load();
+        const format = config.defaultImageFormat;
+        const targetPath = opts.outputPath || resolveOutputPath(imagePath, outDir, format, '_watermarked');
+        // Load watermark metadata to scale it if needed
+        const mainMeta = await sharp(imagePath).metadata();
+        const wmMeta = await sharp(watermarkPath).metadata();
+        if (!mainMeta.width || !mainMeta.height || !wmMeta.width || !wmMeta.height) {
+            throw new Error('Unable to read image metadata.');
+        }
+        // Scale watermark to be max 25% of the main image width
+        const targetWmWidth = Math.floor(mainMeta.width * 0.25);
+        const scaledWm = await sharp(watermarkPath)
+            .resize(targetWmWidth)
+            .toBuffer();
+        await sharp(imagePath)
+            .composite([{
+                input: scaledWm,
+                gravity: 'southeast', // Default bottom-right placement
+            }])
+            .toFile(targetPath);
+        return targetPath;
+    }
+    /**
+     * Background Removal Engine runner
+     */
+    static async removeBg(imagePath, engineType = 'local', opts = {}) {
+        const outDir = opts.outputDir || ConfigManager.getOutputFolder();
+        const targetPath = opts.outputPath || resolveOutputPath(imagePath, outDir, 'png', '_nobg');
+        let engine;
+        if (engineType === 'api') {
+            engine = new ApiBgRemovalEngine();
+        }
+        else {
+            engine = new LocalBgRemovalEngine();
+        }
+        await engine.removeBackground(imagePath, targetPath);
+        return targetPath;
+    }
+}

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

@@ -0,0 +1,14 @@
+export interface OcrEngineOptions {
+    exportFormat?: 'txt' | 'markdown' | 'json';
+    outputDir?: string;
+    outputPath?: string;
+}
+export declare class OcrEngine {
+    /**
+     * Extracts text from an image using Tesseract OCR
+     */
+    static extract(imagePath: string, opts?: OcrEngineOptions): Promise<{
+        text: string;
+        exportedPath?: string;
+    }>;
+}

package/dist/core/ocr/index.js

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+import { createWorker } from 'tesseract.js';
+import { ConfigManager } from '../config/index.js';
+export class OcrEngine {
+    /**
+     * Extracts text from an image using Tesseract OCR
+     */
+    static async extract(imagePath, opts = {}) {
+        // Initialize Tesseract worker
+        const worker = await createWorker('eng');
+        let text = '';
+        try {
+            const { data } = await worker.recognize(imagePath);
+            text = data.text;
+        }
+        finally {
+            await worker.terminate();
+        }
+        if (!opts.exportFormat) {
+            return { text };
+        }
+        // Handle exports
+        const format = opts.exportFormat.toLowerCase();
+        const outDir = opts.outputDir || ConfigManager.getOutputFolder();
+        const baseName = path.basename(imagePath, path.extname(imagePath));
+        const targetPath = opts.outputPath || path.join(outDir, `${baseName}_ocr.${format}`);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        let exportContent = '';
+        if (format === 'json') {
+            exportContent = JSON.stringify({
+                source: path.basename(imagePath),
+                extractedAt: new Date().toISOString(),
+                text: text,
+            }, null, 2);
+        }
+        else if (format === 'markdown') {
+            exportContent = `# OCR Extraction Report\n\n` +
+                `**Source File:** \`${path.basename(imagePath)}\`\n` +
+                `**Extracted At:** ${new Date().toLocaleString()}\n\n` +
+                `## Extracted Content\n\n` +
+                `\`\`\`text\n${text}\n\`\`\`\n`;
+        }
+        else {
+            // Default to plain txt
+            exportContent = text;
+        }
+        fs.writeFileSync(targetPath, exportContent, 'utf-8');
+        return { text, exportedPath: targetPath };
+    }
+}