genmix 1.0.0 → 1.0.4

package/README.md

@@ -45,7 +45,7 @@ const result = await generator.generate(
 );
 
 // Save images
-const savedPaths = generator.save('./output');
+const savedPaths = await generator.save({ directory: './output' });
 console.log('Images saved:', savedPaths);
 ```
 
@@ -62,7 +62,7 @@ const result = await generator.generate(
   }
 );
 
-const savedPaths = generator.save('./output');
+const savedPaths = await generator.save({ directory: './output' });
 ```
 
 ### Using URLs as Reference
@@ -76,7 +76,7 @@ const result = await generator.generate(
   }
 );
 
-generator.save('./output');
+generator.save({ directory: './output' });
 ```
 
 ## Configuration Options
@@ -106,6 +106,46 @@ await generator.generate(prompt, options)
 | `options.quality`        | string        | Quality: '1K', '2K', '4K'                   | -       |
 | `options.aspectRatio`    | string        | Aspect ratio: '1:1', '16:9', '4:3', etc.    | -       |
 
+### save() Method
+
+```javascript
+await generator.save(options)
+```
+
+**Parameters:**
+
+| Option              | Type   | Description                                      | Default |
+| ------------------- | ------ | ------------------------------------------------ | ------- |
+| `options.directory` | string | Target directory path to save images             | `'.'`   |
+| `options.filename`  | string | Custom filename (without extension). If not provided, uses hash-based filename | -       |
+| `options.extension` | string | File format: 'jpg', 'png', 'webp', 'avif', 'tiff' | `'jpg'` |
+
+**Examples:**
+
+```javascript
+// Save to specific directory with auto-generated filename (jpg by default)
+await generator.save({ directory: './output' });
+
+// Save as PNG
+await generator.save({ directory: './output', extension: 'png' });
+
+// Save to specific directory with custom filename
+await generator.save({ directory: './output', filename: 'my-image' });
+
+// Save as WebP with custom filename
+await generator.save({ directory: './output', filename: 'my-image', extension: 'webp' });
+
+// Save to current directory with custom filename
+await generator.save({ filename: 'my-image' });
+
+// Save to current directory with auto-generated filename (jpg)
+await generator.save();
+```
+
+**Note:** 
+- When multiple images are generated and a custom filename is provided, they will be saved as `filename_0.jpg`, `filename_1.jpg`, etc.
+- The method uses Sharp for image conversion, supporting high-quality format conversion
+
 ## Advanced Examples
 
 ### Style Transfer
@@ -179,7 +219,7 @@ try {
   const result = await generator.generate(prompt, options);
   
   if (result.images && result.images.length > 0) {
-    const paths = generator.save('./output');
+    const paths = generator.save({ directory: './output' });
     console.log('Success!', paths);
   } else {
     console.log('No images generated');

package/demo/example-multiple.js

@@ -0,0 +1,49 @@
+process.loadEnvFile(); // Native Node.js .env loading (Node 20.12+)
+const { GeminiGenerator } = require('../index');
+const path = require('path');
+const fs = require('fs');
+
+async function main() {
+    try {
+        const generator = new GeminiGenerator();
+
+        // === Multiple variations of the same image ===
+        const localImagePath = path.join(__dirname, 'camera_4126.jpg');
+        
+        if (fs.existsSync(localImagePath)) {
+            console.log('🎨 Generating multiple variations...\n');
+
+            const result = await generator.generate(
+                'Add a vintage film look with grain and vignette effect',
+                {
+                    referenceImage: localImagePath,
+                    quality: '1K',
+                    numberOfImages: 3
+                }
+            );
+
+            if (result.images && result.images.length > 0) {
+                const saved = await generator.save({ directory: __dirname });
+                console.log(`✅ ${saved.length} variations saved:`);
+                saved.forEach(p => console.log(`   - ${p}`));
+                console.log();
+            }
+        }
+
+        console.log('🎉 Example completed successfully!\n');
+
+    } catch (error) {
+        console.error('❌ Error:', error.message);
+
+        if (error.message.includes('API Key')) {
+            console.error('\n💡 Tip: Make sure you have GEMINI_API_KEY in your .env file');
+        }
+
+        if (error.message.includes('reference image')) {
+            console.error('\n💡 Tip: Verify that the image path is correct');
+        }
+    }
+}
+
+main();
+

package/demo/example-translate.js

@@ -17,42 +17,38 @@ async function main() {
                 'Translate this image to Portuguese',
                 {
                     referenceImage: localImagePath,
-                    quality: '2K',
+                    quality: '1K',
                     numberOfImages: 1
                 }
             );
 
             if (result1.images && result1.images.length > 0) {
-                const saved = generator.save(__dirname);
+                // Create pt directory if it doesn't exist
+                const ptDir = path.join(__dirname, 'pt');
+                if (!fs.existsSync(ptDir)) {
+                    fs.mkdirSync(ptDir, { recursive: true });
+                }
+                
+                // Use the same filename as the original
+                const originalName = path.basename(localImagePath, path.extname(localImagePath));
+                
+                // Get reference metadata to match format
+                const refMetadata = generator.getReferenceMetadata();
+                console.log('📊 Reference format:', refMetadata);
+                
+                // Save with same format as reference
+                const saved = await generator.save({ 
+                    directory: ptDir,
+                    filename: originalName,
+                    formatOptions: refMetadata
+                });
                 console.log('✅ Modified image saved at:', saved[0], '\n');
             } else if (result1.text) {
                 console.log('📝 Result:', result1.text, '\n');
             }
         }
 
-
-        // === Option 3: Multiple variations of the same image ===
-        if (fs.existsSync(localImagePath)) {
-            console.log('🎨 Generating multiple variations...\n');
-
-            const result3 = await generator.generate(
-                'Add a vintage film look with grain and vignette effect',
-                {
-                    referenceImage: localImagePath,
-                    quality: '1K',
-                    numberOfImages: 3
-                }
-            );
-
-            if (result3.images && result3.images.length > 0) {
-                const saved = generator.save(__dirname);
-                console.log(`✅ ${saved.length} variations saved:`);
-                saved.forEach(p => console.log(`   - ${p}`));
-                console.log();
-            }
-        }
-
-        console.log('🎉 All examples completed successfully!\n');
+        console.log('🎉 Example completed successfully!\n');
 
     } catch (error) {
         console.error('❌ Error:', error.message);

package/demo/example.js

@@ -25,7 +25,7 @@ async function exampleBasicGeneration() {
     if (result.images && result.images.length > 0) {
         console.log(`Found ${result.images.length} images.`);
 
-        const savedPaths = generator.save(__dirname);
+        const savedPaths = await generator.save({ directory: __dirname });
         savedPaths.forEach(p => console.log(`Saved image to ${p}`));
     } else {
         console.log('No images generated.');

package/generators/BaseGenerator.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const hashFactory = require('hash-factory');
+const sharp = require('sharp');
 
 class BaseGenerator {
     constructor(config = {}) {
@@ -20,12 +21,15 @@ class BaseGenerator {
     }
 
     /**
-     * Saves generated images to the specified directory using hashed filenames.
-     * @param {string} directory - Target directory path.
-     * @returns {string[]} Array of saved file paths.
+     * Saves generated images to the specified directory using hashed filenames or custom filename.
+     * @param {Object} [options={}] - Save options
+     * @param {string} [options.directory='.'] - Target directory path. Defaults to current directory.
+     * @param {string} [options.filename] - Optional custom filename (without extension). If not provided, uses hashed filenames.
+     * @param {string} [options.extension='jpg'] - File extension: 'jpg', 'png', 'webp', 'avif', 'tiff'. Defaults to 'jpg'.
+     * @param {Object} [options.formatOptions] - Format-specific options (quality, compressionLevel, palette, colours, etc.)
+     * @returns {Promise<string[]>} Promise that resolves to array of saved file paths.
      */
-    save(directory) {
-        const extension = 'png';
+    async save({directory = '.', filename = null, extension = 'jpg', formatOptions = null} = {}) {
         const targetImages = this.lastGeneration?.images;
         const targetPrompt = this.lastGeneration?.prompt;
 
@@ -34,7 +38,7 @@ class BaseGenerator {
             return [];
         }
 
-        if (!targetPrompt) {
+        if (!targetPrompt && !filename) {
             console.warn('No prompt available for hash generation.');
         }
 
@@ -43,18 +47,97 @@ class BaseGenerator {
             fs.mkdirSync(directory, { recursive: true });
         }
 
+        // Use format from formatOptions if provided, otherwise use extension
+        if (formatOptions && formatOptions.format) {
+            extension = formatOptions.format;
+        }
+
+        // Normalize extension
+        extension = extension.toLowerCase().replace(/^\./, '');
+        
+        // Validate extension
+        const supportedFormats = ['jpg', 'jpeg', 'png', 'webp', 'avif', 'tiff', 'tif'];
+        if (!supportedFormats.includes(extension)) {
+            throw new Error(`Unsupported extension: ${extension}. Supported formats: ${supportedFormats.join(', ')}`);
+        }
+
+        // Normalize jpeg/jpg
+        const sharpFormat = extension === 'jpeg' ? 'jpg' : extension;
+        const fileExtension = extension === 'jpeg' ? 'jpg' : extension;
+
         const savedPaths = [];
-        targetImages.forEach((imgData, index) => {
+        
+        for (let index = 0; index < targetImages.length; index++) {
+            const imgData = targetImages[index];
             const base64Data = imgData.replace(/^data:image\/\w+;base64,/, "");
             const buffer = Buffer.from(base64Data, 'base64');
 
-            const hash = this.generateHash(targetPrompt + '_' + index);
-            const fileName = `${hash}.${extension}`;
+            let fileName;
+            if (filename) {
+                // Use custom filename, add index if multiple images
+                if (targetImages.length > 1) {
+                    fileName = `${filename}_${index}.${fileExtension}`;
+                } else {
+                    fileName = `${filename}.${fileExtension}`;
+                }
+            } else {
+                // Use hash-based filename
+                const hash = this.generateHash(targetPrompt + '_' + index);
+                fileName = `${hash}.${fileExtension}`;
+            }
+            
             const outputPath = path.join(directory, fileName);
 
-            fs.writeFileSync(outputPath, buffer);
-            savedPaths.push(outputPath);
-        });
+            // Convert image format using sharp
+            try {
+                let sharpInstance = sharp(buffer);
+                
+                // Resize if dimensions are specified in formatOptions
+                if (formatOptions && formatOptions.width && formatOptions.height) {
+                    sharpInstance = sharpInstance.resize(formatOptions.width, formatOptions.height, {
+                        fit: 'fill'
+                    });
+                }
+                
+                // Build format-specific options
+                const sharpFormatOptions = {};
+                
+                if (formatOptions) {
+                    if (sharpFormat === 'jpg' && formatOptions.quality) {
+                        sharpFormatOptions.quality = formatOptions.quality;
+                    } else if (sharpFormat === 'png') {
+                        if (formatOptions.compressionLevel !== undefined) {
+                            sharpFormatOptions.compressionLevel = formatOptions.compressionLevel;
+                        }
+                        if (formatOptions.quality !== undefined) {
+                            sharpFormatOptions.quality = formatOptions.quality;
+                        }
+                        if (formatOptions.effort !== undefined) {
+                            sharpFormatOptions.effort = formatOptions.effort;
+                        }
+                        if (formatOptions.palette) {
+                            sharpFormatOptions.palette = true;
+                            // Add dithering for better quality with palette
+                            sharpFormatOptions.dither = 1.0;
+                        }
+                        if (formatOptions.colours) {
+                            sharpFormatOptions.colours = formatOptions.colours;
+                        }
+                    } else if (sharpFormat === 'webp' && formatOptions.quality) {
+                        sharpFormatOptions.quality = formatOptions.quality;
+                    }
+                }
+                
+                await sharpInstance
+                    .toFormat(sharpFormat, sharpFormatOptions)
+                    .toFile(outputPath);
+                
+                savedPaths.push(outputPath);
+            } catch (error) {
+                console.error(`Error saving image ${fileName}:`, error.message);
+                throw error;
+            }
+        }
 
         return savedPaths;
     }

package/generators/GeminiGenerator.js

@@ -4,261 +4,342 @@ const fs = require('fs');
 const path = require('path');
 
 class GeminiGenerator extends BaseGenerator {
-  /**
-   * @param {Object} [config]
-   * @param {string} [config.apiKey]
-   * @param {string} [config.modelId]
-   */
-  constructor(config = {}) {
-    super(config);
-    this.apiKey = config.apiKey || process.env.GEMINI_API_KEY;
-
-    if (!this.apiKey) {
-      throw new Error('API Key is required. Provide it in the constructor or set GEMINI_API_KEY environment variable.');
+    /**
+     * @param {Object} [config]
+     * @param {string} [config.apiKey]
+     * @param {string} [config.modelId]
+     */
+    constructor(config = {}) {
+        super(config);
+        this.apiKey = config.apiKey || process.env.GEMINI_API_KEY;
+
+        if (!this.apiKey) {
+            throw new Error('API Key is required. Provide it in the constructor or set GEMINI_API_KEY environment variable.');
+        }
+        // Use the specific model for image generation or default to pro-vision if needed
+        // However, for standard image generation via prompt, specific models like 'gemini-1.5-pro' or 'imagen-3.0-generate-001' are often used.
+        // Keeping the user's modelId preference.
+        this.modelId = config.modelId || 'gemini-3-pro-image-preview';
+        // NOTE: For simple generation, we might not need streamGenerateContent unless we want text streaming.
+        // But let's stick to what worked for text, and adjust the body.
+        this.apiUrl = `https://generativelanguage.googleapis.com/v1beta/models/${this.modelId}:streamGenerateContent`;
+        this.referenceMetadata = null;
     }
-    // Use the specific model for image generation or default to pro-vision if needed
-    // However, for standard image generation via prompt, specific models like 'gemini-1.5-pro' or 'imagen-3.0-generate-001' are often used.
-    // Keeping the user's modelId preference.
-    this.modelId = config.modelId || 'gemini-3-pro-image-preview';
-    // NOTE: For simple generation, we might not need streamGenerateContent unless we want text streaming.
-    // But let's stick to what worked for text, and adjust the body.
-    this.apiUrl = `https://generativelanguage.googleapis.com/v1beta/models/${this.modelId}:streamGenerateContent`;
-  }
-
-  /**
-   * @param {string} prompt
-   * @param {Object} [options]
-   * @param {string|Buffer} [options.referenceImage] - Path to image file, base64 data URI, or Buffer
-   * @param {string} [options.numberOfImages] - Number of images to generate
-   * @param {string} [options.quality] - Image quality: '1K', '2K', '4K'
-   * @param {string} [options.aspectRatio] - Aspect ratio like '1:1', '16:9', etc.
-   * @returns {Promise<{images: string[], text: string, raw: any}>}
-   */
-  async generate(prompt, options = {}) {
-    // If the user asks for multiple images, we might need to make parallel requests
-    // if the API doesn't support candidateCount > 1 for images.
-    // Based on search results, candidateCount > 1 can cause 400 errors.
-    const numberOfImages = options.numberOfImages || 1;
-
-    let result;
-    if (numberOfImages > 1) {
-      result = await this.generateMultiple(prompt, numberOfImages, options);
-    } else {
-      result = await this._generateSingleRequest(prompt, options);
+
+    /**
+     * @param {string} prompt
+     * @param {Object} [options]
+     * @param {string|Buffer} [options.referenceImage] - Path to image file, base64 data URI, or Buffer
+     * @param {string} [options.numberOfImages] - Number of images to generate
+     * @param {string} [options.quality] - Image quality: '1K', '2K', '4K'
+     * @param {string} [options.aspectRatio] - Aspect ratio like '1:1', '16:9', etc.
+     * @returns {Promise<{images: string[], text: string, raw: any}>}
+     */
+    async generate(prompt, options = {}) {
+        // If the user asks for multiple images, we might need to make parallel requests
+        // if the API doesn't support candidateCount > 1 for images.
+        // Based on search results, candidateCount > 1 can cause 400 errors.
+        const numberOfImages = options.numberOfImages || 1;
+
+        let result;
+        if (numberOfImages > 1) {
+            result = await this.generateMultiple(prompt, numberOfImages, options);
+        } else {
+            result = await this._generateSingleRequest(prompt, options);
+        }
+
+        // Store result in state for saveImages()
+        this.lastGeneration = {
+            prompt: prompt,
+            images: result.images,
+            text: result.text,
+            raw: result.raw
+        };
+
+        return result;
     }
 
-    // Store result in state for saveImages()
-    this.lastGeneration = {
-        prompt: prompt,
-        images: result.images,
-        text: result.text,
-        raw: result.raw
-    };
-
-    return result;
-  }
-
-  /**
-   * Processes a reference image and returns base64 data and mime type
-   * @param {string|Buffer} imageInput - File path, base64 data URI, or Buffer
-   * @returns {Promise<{data: string, mimeType: string}>}
-   * @private
-   */
-  async _processReferenceImage(imageInput) {
-    let base64Data;
-    let mimeType = 'image/png'; // default
-
-    if (Buffer.isBuffer(imageInput)) {
-      // If it's already a buffer
-      base64Data = imageInput.toString('base64');
-    } else if (typeof imageInput === 'string') {
-      if (imageInput.startsWith('data:image/')) {
-        // It's a data URI
-        const match = imageInput.match(/^data:(image\/[^;]+);base64,(.+)$/);
-        if (match) {
-          mimeType = match[1];
-          base64Data = match[2];
+    /**
+     * Processes a reference image and returns base64 data and mime type
+     * @param {string|Buffer} imageInput - File path, base64 data URI, or Buffer
+     * @returns {Promise<{data: string, mimeType: string}>}
+     * @private
+     */
+    async _processReferenceImage(imageInput) {
+        let base64Data;
+        let mimeType = 'image/png'; // default
+
+        if (Buffer.isBuffer(imageInput)) {
+            // If it's already a buffer
+            base64Data = imageInput.toString('base64');
+        } else if (typeof imageInput === 'string') {
+            if (imageInput.startsWith('data:image/')) {
+                // It's a data URI
+                const match = imageInput.match(/^data:(image\/[^;]+);base64,(.+)$/);
+                if (match) {
+                    mimeType = match[1];
+                    base64Data = match[2];
+                } else {
+                    throw new Error('Invalid data URI format for reference image');
+                }
+            } else if (imageInput.startsWith('http://') || imageInput.startsWith('https://')) {
+                // It's a URL - download it
+                try {
+                    const response = await axios.get(imageInput, { responseType: 'arraybuffer' });
+                    base64Data = Buffer.from(response.data).toString('base64');
+                    mimeType = response.headers['content-type'] || 'image/png';
+                } catch (error) {
+                    throw new Error(`Failed to download reference image from URL: ${error.message}`);
+                }
+            } else {
+                // Assume it's a file path
+                try {
+                    const fileBuffer = fs.readFileSync(imageInput);
+                    base64Data = fileBuffer.toString('base64');
+
+                    // Determine mime type from extension
+                    const ext = path.extname(imageInput).toLowerCase();
+                    const mimeTypes = {
+                        '.png': 'image/png',
+                        '.jpg': 'image/jpeg',
+                        '.jpeg': 'image/jpeg',
+                        '.gif': 'image/gif',
+                        '.webp': 'image/webp'
+                    };
+                    mimeType = mimeTypes[ext] || 'image/png';
+
+                    // Extract metadata from reference image using sharp
+                    await this._extractReferenceMetadata(imageInput);
+                } catch (error) {
+                    throw new Error(`Failed to read reference image file: ${error.message}`);
+                }
+            }
         } else {
-          throw new Error('Invalid data URI format for reference image');
+            throw new Error('Reference image must be a file path, URL, data URI, or Buffer');
         }
-      } else if (imageInput.startsWith('http://') || imageInput.startsWith('https://')) {
-        // It's a URL - download it
+
+        return { data: base64Data, mimeType };
+    }
+
+    /**
+     * Extract metadata from reference image
+     * @param {string} imagePath - Path to the reference image
+     * @private
+     */
+    async _extractReferenceMetadata(imagePath) {
+        const sharp = require('sharp');
         try {
-          const response = await axios.get(imageInput, { responseType: 'arraybuffer' });
-          base64Data = Buffer.from(response.data).toString('base64');
-          mimeType = response.headers['content-type'] || 'image/png';
+            const image = sharp(imagePath);
+            const metadata = await image.metadata();
+            const stats = fs.statSync(imagePath);
+
+            // Build format options based on image format
+            const formatOptions = {
+                format: metadata.format,
+                width: metadata.width,
+                height: metadata.height
+            };
+
+            // Format-specific options
+            if (metadata.format === 'jpeg' || metadata.format === 'jpg') {
+                // Estimate quality from file size (heuristic)
+                const pixelCount = metadata.width * metadata.height;
+                const bytesPerPixel = stats.size / pixelCount;
+
+                // Quality estimation based on bytes per pixel
+                if (bytesPerPixel < 0.5) formatOptions.quality = 70;
+                else if (bytesPerPixel < 1) formatOptions.quality = 80;
+                else if (bytesPerPixel < 1.5) formatOptions.quality = 90;
+                else formatOptions.quality = 90;
+            } else if (metadata.format === 'png') {
+                formatOptions.compressionLevel = 9;
+
+                // Check if it's a palette PNG using paletteBitDepth
+                if (metadata.paletteBitDepth) {
+                    formatOptions.palette = true;
+                    formatOptions.quality = 90; // Max quality for palette PNG
+                    formatOptions.effort = 9; // Maximum compression effort
+
+                    // Count actual unique colors in the image
+                    try {
+                        const { data, info } = await sharp(imagePath).raw().toBuffer({ resolveWithObject: true });
+                        const colors = new Set();
+                        const pixelSize = info.channels;
+
+                        for (let i = 0; i < data.length; i += pixelSize) {
+                            const color = [];
+                            for (let j = 0; j < pixelSize; j++) {
+                                color.push(data[i + j]);
+                            }
+                            colors.add(color.join(','));
+                        }
+
+                        formatOptions.colours = colors.size;
+                    } catch (error) {
+                        // Fallback to paletteBitDepth calculation if color counting fails
+                        formatOptions.colours = Math.pow(2, metadata.paletteBitDepth);
+                    }
+                }
+            } else if (metadata.format === 'webp') {
+                formatOptions.quality = 80;
+            }
+
+            this.referenceMetadata = formatOptions;
         } catch (error) {
-          throw new Error(`Failed to download reference image from URL: ${error.message}`);
+            console.warn('Could not extract reference metadata:', error.message);
         }
-      } else {
-        // Assume it's a file path
+    }
+
+    /**
+     * Get metadata from the last processed reference image
+     * @returns {Object|null} Metadata object or null if no reference processed
+     */
+    getReferenceMetadata() {
+        return this.referenceMetadata;
+    }
+
+    async generateMultiple(prompt, count, options) {
+        const promises = [];
+        for (let i = 0; i < count; i++) {
+            promises.push(this._generateSingleRequest(prompt, options));
+        }
+
         try {
-          const fileBuffer = fs.readFileSync(imageInput);
-          base64Data = fileBuffer.toString('base64');
-          
-          // Determine mime type from extension
-          const ext = path.extname(imageInput).toLowerCase();
-          const mimeTypes = {
-            '.png': 'image/png',
-            '.jpg': 'image/jpeg',
-            '.jpeg': 'image/jpeg',
-            '.gif': 'image/gif',
-            '.webp': 'image/webp'
-          };
-          mimeType = mimeTypes[ext] || 'image/png';
+            const results = await Promise.all(promises);
+
+            const merged = {
+                images: [],
+                text: '',
+                raw: results.map(r => r.raw),
+            };
+
+            for (const res of results) {
+                merged.images.push(...res.images);
+                if (res.text && !merged.text.includes(res.text)) {
+                    merged.text += res.text + '\n';
+                }
+            }
+            return merged;
         } catch (error) {
-          throw new Error(`Failed to read reference image file: ${error.message}`);
+            throw error;
         }
-      }
-    } else {
-      throw new Error('Reference image must be a file path, URL, data URI, or Buffer');
     }
 
-    return { data: base64Data, mimeType };
-  }
+    async _generateSingleRequest(prompt, options) {
+        const url = `${this.apiUrl}?key=${this.apiKey}`;
 
-  async generateMultiple(prompt, count, options) {
-    const promises = [];
-    for (let i = 0; i < count; i++) {
-      promises.push(this._generateSingleRequest(prompt, options));
-    }
+        // Build the parts array
+        const parts = [];
 
-    try {
-      const results = await Promise.all(promises);
-      
-      const merged = {
-        images: [],
-        text: '',
-        raw: results.map(r => r.raw),
-      };
-
-      for (const res of results) {
-        merged.images.push(...res.images);
-        if (res.text && !merged.text.includes(res.text)) {
-             merged.text += res.text + '\n';
+        // Add reference image if provided
+        if (options.referenceImage) {
+            const imageData = await this._processReferenceImage(options.referenceImage);
+            parts.push({
+                inlineData: {
+                    mimeType: imageData.mimeType,
+                    data: imageData.data
+                }
+            });
         }
-      }
-      return merged;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async _generateSingleRequest(prompt, options) {
-     const url = `${this.apiUrl}?key=${this.apiKey}`;
-
-     // Build the parts array
-     const parts = [];
-     
-     // Add reference image if provided
-     if (options.referenceImage) {
-       const imageData = await this._processReferenceImage(options.referenceImage);
-       parts.push({
-         inlineData: {
-           mimeType: imageData.mimeType,
-           data: imageData.data
-         }
-       });
-     }
-     
-     // Add text prompt
-     parts.push({
-       text: prompt,
-     });
-
-     // Simplified data structure to minimize conflicts
-     const data = {
-      contents: [
-        {
-          role: 'user', // Role is good practice
-          parts: parts,
-        },
-      ],
-      // Only include generationConfig if there are specific options to set
-      generationConfig: {
-         // 'responseModalities' is often implied or specific to the model.
-         // Removing explicit 'responseModalities' might help if the model detects intent from prompt.
-         // But let's keep basic structure.
-         // candidateCount MUST be 1 for many image models per request.
-         candidateCount: 1, 
-      },
-    };
-    
-    // Only add imageConfig if it's actually supported/needed. 
-    // Some models might reject 'imageConfig' inside 'generationConfig' if they expect text.
-    // However, if we are targeting an image model, we need to be careful.
-    // Let's try sending a cleaner request first.
-    
-    // If specific image options are passed, add them carefully
-    if (options.imageSize || options.aspectRatio || options.quality) {
-         // Note: Not all models support 'imageConfig' this way. 
-         // But if the user is using a model that supports it...
-         data.generationConfig.imageConfig = {};
-         
-         // User mentioned quality is 1k, 2k, 4k. Mapping quality or imageSize to this.
-         const size = options.quality || options.imageSize;
-         if (size) {
-             data.generationConfig.imageConfig.image_size = size; // Expects '1K', '2K', '4K'
-         }
-         
-         if (options.aspectRatio) {
-             data.generationConfig.imageConfig.aspect_ratio = options.aspectRatio;
-         }
-    }
 
-    // Remove 'tools' unless explicitly requested or needed for search grounding.
-    // 'googleSearch' tool might conflict with pure image generation intent on some endpoints.
-    // data.tools = ... (removed)
-
-    try {
-      const response = await axios.post(url, data, {
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      });
-
-      return this.processResponse(response.data);
-    } catch (error) {
-      const errorMessage = error.response?.data?.error?.message || error.message;
-      // Log detailed error for debugging
-      if (error.response?.data) {
-          console.error("API Error Details:", JSON.stringify(error.response.data, null, 2));
-      }
-      throw new Error(`Gemini API Error: ${errorMessage}`);
-    }
-  }
-
-  processResponse(data) {
-    // Handle stream response which might be an array of chunks
-    const chunks = Array.isArray(data) ? data : [data];
-    const images = [];
-    let fullText = '';
-
-    for (const chunk of chunks) {
-      if (chunk.candidates) {
-        for (const candidate of chunk.candidates) {
-          if (candidate.content && candidate.content.parts) {
-            for (const part of candidate.content.parts) {
-              if (part.text) {
-                fullText += part.text;
-              }
-              if (part.inlineData && part.inlineData.mimeType.startsWith('image/')) {
-                // Base64 image data
-                images.push(`data:${part.inlineData.mimeType};base64,${part.inlineData.data}`);
-              }
-              // Handle executable code or other parts if necessary
+        // Add text prompt
+        parts.push({
+            text: prompt,
+        });
+
+        // Simplified data structure to minimize conflicts
+        const data = {
+            contents: [
+                {
+                    role: 'user', // Role is good practice
+                    parts: parts,
+                },
+            ],
+            // Only include generationConfig if there are specific options to set
+            generationConfig: {
+                // 'responseModalities' is often implied or specific to the model.
+                // Removing explicit 'responseModalities' might help if the model detects intent from prompt.
+                // But let's keep basic structure.
+                // candidateCount MUST be 1 for many image models per request.
+                candidateCount: 1,
+            },
+        };
+
+        // Only add imageConfig if it's actually supported/needed. 
+        // Some models might reject 'imageConfig' inside 'generationConfig' if they expect text.
+        // However, if we are targeting an image model, we need to be careful.
+        // Let's try sending a cleaner request first.
+
+        // If specific image options are passed, add them carefully
+        if (options.imageSize || options.aspectRatio || options.quality) {
+            // Note: Not all models support 'imageConfig' this way. 
+            // But if the user is using a model that supports it...
+            data.generationConfig.imageConfig = {};
+
+            // User mentioned quality is 1k, 2k, 4k. Mapping quality or imageSize to this.
+            const size = options.quality || options.imageSize;
+            if (size) {
+                data.generationConfig.imageConfig.image_size = size; // Expects '1K', '2K', '4K'
+            }
+
+            if (options.aspectRatio) {
+                data.generationConfig.imageConfig.aspect_ratio = options.aspectRatio;
             }
-          }
         }
-      }
+
+        // Remove 'tools' unless explicitly requested or needed for search grounding.
+        // 'googleSearch' tool might conflict with pure image generation intent on some endpoints.
+        // data.tools = ... (removed)
+
+        try {
+            const response = await axios.post(url, data, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+
+            return this.processResponse(response.data);
+        } catch (error) {
+            const errorMessage = error.response?.data?.error?.message || error.message;
+            // Log detailed error for debugging
+            if (error.response?.data) {
+                console.error("API Error Details:", JSON.stringify(error.response.data, null, 2));
+            }
+            throw new Error(`Gemini API Error: ${errorMessage}`);
+        }
     }
 
-    return {
-      images,
-      text: fullText,
-      raw: data,
-    };
-  }
+    processResponse(data) {
+        // Handle stream response which might be an array of chunks
+        const chunks = Array.isArray(data) ? data : [data];
+        const images = [];
+        let fullText = '';
+
+        for (const chunk of chunks) {
+            if (chunk.candidates) {
+                for (const candidate of chunk.candidates) {
+                    if (candidate.content && candidate.content.parts) {
+                        for (const part of candidate.content.parts) {
+                            if (part.text) {
+                                fullText += part.text;
+                            }
+                            if (part.inlineData && part.inlineData.mimeType.startsWith('image/')) {
+                                // Base64 image data
+                                images.push(`data:${part.inlineData.mimeType};base64,${part.inlineData.data}`);
+                            }
+                            // Handle executable code or other parts if necessary
+                        }
+                    }
+                }
+            }
+        }
+
+        return {
+            images,
+            text: fullText,
+            raw: data,
+        };
+    }
 }
 
 module.exports = GeminiGenerator;

package/package.json

@@ -1,9 +1,23 @@
 {
   "name": "genmix",
-  "version": "1.0.0",
-  "description": "",
-  "license": "ISC",
-  "author": "",
+  "version": "1.0.4",
+  "description": "AI-powered image generator using Google Gemini API. Supports image generation from text prompts and image modification with reference images.",
+  "license": "MIT",
+  "author": "Martin Clasen",
+  "keywords": [
+    "nano",
+    "banana",
+    "pro",
+    "image-generator",
+    "google-gemini",
+    "gemini-api",
+    "text-to-image",
+    "image-modification",
+    "style-transfer",
+    "generative-ai",
+    "genmix",
+    "clasen"
+  ],
   "type": "commonjs",
   "main": "index.js",
   "scripts": {
@@ -11,6 +25,7 @@
   },
   "dependencies": {
     "axios": "^1.13.2",
-    "hash-factory": "^1.1.2"
+    "hash-factory": "^1.1.2",
+    "sharp": "^0.33.5"
   }
 }

package/demo/.env

@@ -1 +0,0 @@
-GEMINI_API_KEY="AIzaSyDMy_iCPVzMHF3sSrbCYr2K9PO9lHkCPsg"

package/demo/genmix/generators/BaseGenerator.js

@@ -1,58 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const hashFactory = require('hash-factory');
-
-class BaseGenerator {
-  constructor(config = {}) {
-    this.config = config;
-  }
-
-  /**
-   * Generates a hash from the text prompt.
-   * @param {string} prompt 
-   * @param {Object} options 
-   * @returns {string}
-   */
-  generateHash(prompt, options = { length: 10 }) {
-    return hashFactory(prompt, options);
-  }
-
-  /**
-   * Saves generated images to the specified directory using hashed filenames.
-   * @param {string[]} images - Array of base64 image strings.
-   * @param {string} directory - Target directory path.
-   * @param {string} prompt - The prompt used for generation (to create hash).
-   * @param {string} [extension='png'] - File extension.
-   * @returns {string[]} Array of saved file paths.
-   */
-  saveImages(images, directory, prompt, extension = 'png') {
-    if (!images || !Array.isArray(images) || images.length === 0) {
-      return [];
-    }
-
-    // Ensure directory exists
-    if (!fs.existsSync(directory)) {
-      fs.mkdirSync(directory, { recursive: true });
-    }
-
-    const savedPaths = [];
-    const hash = this.generateHash(prompt);
-
-    images.forEach((imgData, index) => {
-      const base64Data = imgData.replace(/^data:image\/\w+;base64,/, "");
-      const buffer = Buffer.from(base64Data, 'base64');
-      
-      // Using format: hash_index.ext
-      const fileName = `${hash}_${index + 1}.${extension}`;
-      const outputPath = path.join(directory, fileName);
-      
-      fs.writeFileSync(outputPath, buffer);
-      savedPaths.push(outputPath);
-    });
-
-    return savedPaths;
-  }
-}
-
-module.exports = BaseGenerator;
-