maistro 1.0.390

package/dist/imageManager.js

@@ -0,0 +1,674 @@
+import { mkdir, copyFile, unlink, stat, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, basename, extname } from 'node:path';
+import { loadState, saveState } from './taskQueue.js';
+import { DEFAULT_CONFIG } from './types.js';
+import { getLogger } from './logger.js';
+/**
+ * Supported image extensions
+ */
+const IMAGE_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg'];
+/**
+ * MIME types for supported image formats
+ */
+const MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.bmp': 'image/bmp',
+    '.svg': 'image/svg+xml',
+};
+/**
+ * Get the images directory path for a project
+ */
+export function getImagesDir(projectPath) {
+    return join(projectPath, '.maistro', 'images');
+}
+/**
+ * Get the state file path for a project
+ */
+function getStatePath(projectPath) {
+    return join(projectPath, DEFAULT_CONFIG.statePath);
+}
+/**
+ * Sanitize an image ID for use as a filename
+ * - Lowercase
+ * - Replace spaces and special chars with hyphens
+ * - Remove consecutive hyphens
+ */
+export function sanitizeImageId(id) {
+    return id
+        .toLowerCase()
+        .replace(/[^a-z0-9-_]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Check if a string looks like an image file path
+ */
+export function looksLikeImagePath(input) {
+    const ext = extname(input).toLowerCase();
+    return IMAGE_EXTENSIONS.includes(ext);
+}
+/**
+ * Check if a string looks like an image URL
+ * Accepts any HTTP/HTTPS URL that:
+ * - Has an image extension in the path (before query params)
+ * - Includes common image-related path segments
+ * - Is from known image hosting services
+ * - Has an image extension anywhere in the URL (including query params)
+ */
+export function looksLikeImageUrl(input) {
+    try {
+        const url = new URL(input);
+        if (!['http:', 'https:'].includes(url.protocol)) {
+            return false;
+        }
+        const pathname = url.pathname.toLowerCase();
+        const fullUrl = input.toLowerCase();
+        // Check if path ends with image extension
+        if (IMAGE_EXTENSIONS.some(ext => pathname.endsWith(ext))) {
+            return true;
+        }
+        // Check if URL (including query params) contains image extension
+        // This handles URLs like: image.png?token=xxx or ?file=photo.jpg
+        if (IMAGE_EXTENSIONS.some(ext => fullUrl.includes(ext))) {
+            return true;
+        }
+        // Check common image-related path patterns
+        if (pathname.includes('/image') || pathname.includes('/photo') ||
+            pathname.includes('/picture') || pathname.includes('/media') ||
+            pathname.includes('/upload') || pathname.includes('/asset')) {
+            return true;
+        }
+        // Check known image hosting services
+        const hostname = url.hostname.toLowerCase();
+        const imageHosts = [
+            'imgur.com', 'i.imgur.com',
+            'cloudinary.com', 'res.cloudinary.com',
+            'unsplash.com', 'images.unsplash.com',
+            'pexels.com', 'images.pexels.com',
+            'flickr.com', 'staticflickr.com',
+            'giphy.com', 'media.giphy.com',
+            'gravatar.com',
+            'googleusercontent.com',
+            'githubusercontent.com', 'raw.githubusercontent.com',
+            'drive.google.com',
+            'dropbox.com', 'dl.dropboxusercontent.com',
+            'ibb.co', 'i.ibb.co',
+            'imgbb.com',
+            'postimg.cc', 'i.postimg.cc',
+            'prnt.sc', 'prntscr.com',
+            's3.amazonaws.com',
+            'blob.core.windows.net',
+            'storage.googleapis.com',
+        ];
+        if (imageHosts.some(host => hostname === host || hostname.endsWith('.' + host))) {
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Extract image placeholders from text
+ * Supports:
+ * - [image:name], [img:name] - generic image references
+ * - [task-X-image-Y] - task-specific image references (e.g., [task-1-image-1])
+ */
+export function extractImagePlaceholders(text) {
+    const patterns = [
+        /\[image:([a-zA-Z0-9_-]+)\]/gi,
+        /\[img:([a-zA-Z0-9_-]+)\]/gi,
+        /\[(task-[a-zA-Z0-9]+-image-\d+)\]/gi, // task-specific format
+    ];
+    const refs = new Set();
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            refs.add(match[1].toLowerCase());
+        }
+    }
+    return Array.from(refs);
+}
+/**
+ * Extract image URLs from text
+ * Returns an array of unique image URLs found in the text
+ */
+export function extractImageUrls(text) {
+    // Match URLs that look like images
+    // Pattern matches http:// or https:// followed by URL characters
+    const urlPattern = /https?:\/\/[^\s<>"')\]]+/gi;
+    const matches = text.match(urlPattern) || [];
+    const urls = new Set();
+    for (const match of matches) {
+        // Clean up trailing punctuation that might have been captured
+        let url = match.replace(/[.,;:!?]+$/, '');
+        // Also remove trailing parentheses if not balanced
+        if (url.endsWith(')') && (url.match(/\(/g) || []).length < (url.match(/\)/g) || []).length) {
+            url = url.slice(0, -1);
+        }
+        if (looksLikeImageUrl(url)) {
+            urls.add(url);
+        }
+    }
+    return Array.from(urls);
+}
+/**
+ * Process a task description to download image URLs and replace them with placeholders
+ * Returns the updated description and any image metadata that was created
+ */
+export async function processDescriptionImageUrls(projectPath, description, taskId) {
+    const logger = getLogger();
+    const urls = extractImageUrls(description);
+    const downloadedImages = [];
+    const errors = [];
+    let updatedDescription = description;
+    if (urls.length === 0) {
+        return { updatedDescription, downloadedImages, errors };
+    }
+    logger?.info('Processing image URLs in description', {
+        taskId,
+        urlCount: urls.length,
+        urls,
+    });
+    // Get the next available image index for this task
+    let imageIndex = await getNextTaskImageIndex(projectPath, taskId);
+    for (const url of urls) {
+        const imageId = getTaskImageId(taskId, imageIndex);
+        const result = await addImageFromUrl(projectPath, url, imageId);
+        if (result.success && result.metadata) {
+            // Replace the URL with the placeholder
+            const placeholder = getImagePlaceholder(taskId, imageIndex);
+            updatedDescription = updatedDescription.replace(url, placeholder);
+            downloadedImages.push(result.metadata);
+            imageIndex++;
+            logger?.info('Image downloaded and replaced', {
+                url,
+                imageId,
+                placeholder,
+            });
+        }
+        else {
+            const error = `Failed to download image from ${url}: ${result.error}`;
+            errors.push(error);
+            logger?.warn('Failed to download image', { url, error: result.error });
+        }
+    }
+    return { updatedDescription, downloadedImages, errors };
+}
+/**
+ * Get the storage path for an image
+ */
+export function getImageStoragePath(imageId, extension) {
+    return `${sanitizeImageId(imageId)}${extension}`;
+}
+/**
+ * Get the absolute path to an image file
+ */
+export function getImageAbsolutePath(projectPath, storagePath) {
+    return join(getImagesDir(projectPath), storagePath);
+}
+/**
+ * Add an image from a local file path
+ */
+export async function addImageFromFile(projectPath, filePath, imageId, description) {
+    try {
+        // Validate file exists
+        if (!existsSync(filePath)) {
+            return { success: false, error: `File not found: ${filePath}` };
+        }
+        // Validate extension
+        const ext = extname(filePath).toLowerCase();
+        if (!IMAGE_EXTENSIONS.includes(ext)) {
+            return { success: false, error: `Unsupported image format: ${ext}` };
+        }
+        // Get file stats
+        const stats = await stat(filePath);
+        // Ensure images directory exists
+        const imagesDir = getImagesDir(projectPath);
+        await mkdir(imagesDir, { recursive: true });
+        // Create storage path
+        const storagePath = getImageStoragePath(imageId, ext);
+        const destPath = join(imagesDir, storagePath);
+        // Copy file
+        await copyFile(filePath, destPath);
+        // Create metadata
+        const metadata = {
+            id: sanitizeImageId(imageId),
+            originalName: basename(filePath),
+            storagePath,
+            mimeType: MIME_TYPES[ext] || 'application/octet-stream',
+            size: stats.size,
+            description,
+            source: 'file',
+            createdAt: new Date().toISOString(),
+        };
+        // Save to state
+        await saveImageMetadata(projectPath, metadata);
+        return { success: true, metadata };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}
+/**
+ * Add an image from a URL (download)
+ */
+export async function addImageFromUrl(projectPath, url, imageId, description) {
+    try {
+        // Validate URL
+        const parsedUrl = new URL(url);
+        if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+            return { success: false, error: 'Only HTTP/HTTPS URLs are supported' };
+        }
+        // Download the image
+        const response = await fetch(url);
+        if (!response.ok) {
+            return { success: false, error: `Failed to download: ${response.status} ${response.statusText}` };
+        }
+        // Get content type and determine extension
+        const contentType = response.headers.get('content-type') || '';
+        let ext = '.png'; // Default
+        for (const [extension, mime] of Object.entries(MIME_TYPES)) {
+            if (contentType.includes(mime.split('/')[1])) {
+                ext = extension;
+                break;
+            }
+        }
+        // If content-type didn't help, try URL path
+        const urlExt = extname(parsedUrl.pathname).toLowerCase();
+        if (IMAGE_EXTENSIONS.includes(urlExt)) {
+            ext = urlExt;
+        }
+        // Get image data
+        const buffer = Buffer.from(await response.arrayBuffer());
+        // Ensure images directory exists
+        const imagesDir = getImagesDir(projectPath);
+        await mkdir(imagesDir, { recursive: true });
+        // Create storage path
+        const storagePath = getImageStoragePath(imageId, ext);
+        const destPath = join(imagesDir, storagePath);
+        // Write file
+        await writeFile(destPath, buffer);
+        // Create metadata
+        const metadata = {
+            id: sanitizeImageId(imageId),
+            originalName: basename(parsedUrl.pathname) || `${imageId}${ext}`,
+            storagePath,
+            mimeType: MIME_TYPES[ext] || contentType,
+            size: buffer.length,
+            description,
+            source: 'url',
+            sourceUrl: url,
+            createdAt: new Date().toISOString(),
+        };
+        // Save to state
+        await saveImageMetadata(projectPath, metadata);
+        return { success: true, metadata };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}
+/**
+ * Get all images for a project
+ */
+export async function getImages(projectPath) {
+    const statePath = getStatePath(projectPath);
+    const state = await loadState(statePath);
+    return state?.images || {};
+}
+/**
+ * Get a single image by ID
+ */
+export async function getImage(projectPath, imageId) {
+    const images = await getImages(projectPath);
+    return images[sanitizeImageId(imageId)] || null;
+}
+/**
+ * Delete an image
+ */
+export async function deleteImage(projectPath, imageId) {
+    try {
+        const sanitizedId = sanitizeImageId(imageId);
+        const images = await getImages(projectPath);
+        const metadata = images[sanitizedId];
+        if (!metadata) {
+            return { success: false, error: `Image not found: ${imageId}` };
+        }
+        // Delete the file
+        const filePath = getImageAbsolutePath(projectPath, metadata.storagePath);
+        if (existsSync(filePath)) {
+            await unlink(filePath);
+        }
+        // Remove from state
+        await removeImageMetadata(projectPath, sanitizedId);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}
+/**
+ * Save image metadata to project state
+ */
+async function saveImageMetadata(projectPath, metadata) {
+    const statePath = getStatePath(projectPath);
+    const state = await loadState(statePath);
+    if (!state) {
+        throw new Error('No project state found. Initialize a project first.');
+    }
+    if (!state.images) {
+        state.images = {};
+    }
+    state.images[metadata.id] = metadata;
+    await saveState(statePath, state);
+}
+/**
+ * Remove image metadata from project state
+ */
+async function removeImageMetadata(projectPath, imageId) {
+    const statePath = getStatePath(projectPath);
+    const state = await loadState(statePath);
+    if (!state || !state.images)
+        return;
+    delete state.images[imageId];
+    await saveState(statePath, state);
+}
+/**
+ * Format image size for display
+ */
+export function formatImageSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes}B`;
+    }
+    else if (bytes < 1024 * 1024) {
+        return `${Math.round(bytes / 1024)}KB`;
+    }
+    else {
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    }
+}
+/**
+ * Generate a task-specific image ID
+ * Format: task-{taskId}-image-{index}
+ */
+export function getTaskImageId(taskId, imageIndex) {
+    return `task-${taskId}-image-${imageIndex}`;
+}
+/**
+ * Generate a placeholder string for a task image
+ * Format: [task-{taskId}-image-{index}]
+ */
+export function getImagePlaceholder(taskId, imageIndex) {
+    return `[${getTaskImageId(taskId, imageIndex)}]`;
+}
+/**
+ * Save an image for a specific task
+ * Convenience wrapper that uses task-specific naming convention
+ */
+export async function saveTaskImage(projectPath, sourcePath, taskId, imageIndex, description) {
+    const imageId = getTaskImageId(taskId, imageIndex);
+    const result = await addImageFromFile(projectPath, sourcePath, imageId, description);
+    if (result.success) {
+        return {
+            ...result,
+            placeholder: getImagePlaceholder(taskId, imageIndex),
+        };
+    }
+    return result;
+}
+/**
+ * Get the next available image index for a task
+ */
+export async function getNextTaskImageIndex(projectPath, taskId) {
+    const images = await getImages(projectPath);
+    const prefix = `task-${taskId}-image-`;
+    let maxIndex = 0;
+    for (const id of Object.keys(images)) {
+        if (id.startsWith(prefix)) {
+            const indexStr = id.slice(prefix.length);
+            const index = parseInt(indexStr, 10);
+            if (!isNaN(index) && index >= maxIndex) {
+                maxIndex = index + 1;
+            }
+        }
+    }
+    return maxIndex;
+}
+/**
+ * Magic bytes for common image formats
+ * These are the first few bytes that identify image file types
+ */
+const IMAGE_MAGIC_BYTES = {
+    png: { bytes: [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A], ext: '.png', mime: 'image/png' },
+    jpeg: { bytes: [0xFF, 0xD8, 0xFF], ext: '.jpg', mime: 'image/jpeg' },
+    gif: { bytes: [0x47, 0x49, 0x46, 0x38], ext: '.gif', mime: 'image/gif' },
+    webp: { bytes: [0x52, 0x49, 0x46, 0x46], ext: '.webp', mime: 'image/webp' }, // RIFF header, followed by WEBP
+    bmp: { bytes: [0x42, 0x4D], ext: '.bmp', mime: 'image/bmp' },
+};
+/**
+ * Detect if a string contains base64-encoded image data
+ *
+ * Supports:
+ * - Raw base64 data (detects by magic bytes after decoding)
+ * - Data URLs (data:image/png;base64,...)
+ * - iTerm2 inline image sequences (ESC]1337;File=...)
+ *
+ * @param input The string to check for image data
+ * @returns Detection result with buffer and format info if found
+ */
+export function detectPastedImage(input) {
+    const logger = getLogger();
+    // Skip short strings and obvious non-image content
+    if (!input || input.length < 20) {
+        return { detected: false };
+    }
+    // Check for data URL format: data:image/TYPE;base64,DATA
+    const dataUrlMatch = input.match(/^data:image\/([a-z+]+);base64,(.+)$/i);
+    if (dataUrlMatch) {
+        const mimeSubtype = dataUrlMatch[1].toLowerCase();
+        const base64Data = dataUrlMatch[2];
+        try {
+            const buffer = Buffer.from(base64Data, 'base64');
+            if (buffer.length < 8) {
+                return { detected: false, error: 'Decoded data too small' };
+            }
+            // Find matching format
+            const format = detectFormatFromBuffer(buffer);
+            if (format) {
+                return {
+                    detected: true,
+                    buffer,
+                    format: format.name,
+                    extension: format.ext,
+                    mimeType: format.mime,
+                };
+            }
+            // Trust the data URL MIME type even if magic bytes don't match exactly
+            const ext = mimeSubtype === 'jpeg' || mimeSubtype === 'jpg' ? '.jpg' : `.${mimeSubtype}`;
+            return {
+                detected: true,
+                buffer,
+                format: mimeSubtype,
+                extension: ext,
+                mimeType: `image/${mimeSubtype}`,
+            };
+        }
+        catch (err) {
+            logger?.warn('detectPastedImage: failed to decode data URL', { error: String(err) });
+            return { detected: false, error: 'Failed to decode base64 data' };
+        }
+    }
+    // Check for iTerm2 inline image protocol: ESC]1337;File=...
+    // Format: \x1b]1337;File=[params]:BASE64_DATA\x07 or \x1b]1337;File=[params]:BASE64_DATA\x1b\\
+    const iterm2Match = input.match(/\x1b\]1337;File=[^:]*:([A-Za-z0-9+/=]+)(?:\x07|\x1b\\)/);
+    if (iterm2Match) {
+        const base64Data = iterm2Match[1];
+        try {
+            const buffer = Buffer.from(base64Data, 'base64');
+            if (buffer.length < 8) {
+                return { detected: false, error: 'Decoded data too small' };
+            }
+            const format = detectFormatFromBuffer(buffer);
+            if (format) {
+                return {
+                    detected: true,
+                    buffer,
+                    format: format.name,
+                    extension: format.ext,
+                    mimeType: format.mime,
+                };
+            }
+            // Default to PNG if format detection fails
+            return {
+                detected: true,
+                buffer,
+                format: 'png',
+                extension: '.png',
+                mimeType: 'image/png',
+            };
+        }
+        catch (err) {
+            logger?.warn('detectPastedImage: failed to decode iTerm2 data', { error: String(err) });
+            return { detected: false, error: 'Failed to decode iTerm2 image data' };
+        }
+    }
+    // Check for raw base64 data (must look like valid base64 and decode to valid image)
+    // Only consider if the string is mostly base64 characters
+    const trimmed = input.trim();
+    if (/^[A-Za-z0-9+/=]+$/.test(trimmed) && trimmed.length >= 100) {
+        try {
+            const buffer = Buffer.from(trimmed, 'base64');
+            if (buffer.length < 8) {
+                return { detected: false };
+            }
+            const format = detectFormatFromBuffer(buffer);
+            if (format) {
+                return {
+                    detected: true,
+                    buffer,
+                    format: format.name,
+                    extension: format.ext,
+                    mimeType: format.mime,
+                };
+            }
+        }
+        catch {
+            // Not valid base64
+        }
+    }
+    return { detected: false };
+}
+/**
+ * Detect image format from buffer by checking magic bytes
+ */
+function detectFormatFromBuffer(buffer) {
+    for (const [name, { bytes, ext, mime }] of Object.entries(IMAGE_MAGIC_BYTES)) {
+        if (buffer.length >= bytes.length) {
+            let matches = true;
+            for (let i = 0; i < bytes.length; i++) {
+                if (buffer[i] !== bytes[i]) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches) {
+                // For WebP, also check for 'WEBP' signature at offset 8
+                if (name === 'webp') {
+                    if (buffer.length >= 12 &&
+                        buffer[8] === 0x57 && // W
+                        buffer[9] === 0x45 && // E
+                        buffer[10] === 0x42 && // B
+                        buffer[11] === 0x50) { // P
+                        return { name, ext, mime };
+                    }
+                    continue; // Not actually WebP
+                }
+                return { name, ext, mime };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Add an image from pasted base64 data
+ *
+ * @param projectPath Project directory path
+ * @param pastedData The pasted string (base64, data URL, or escape sequence)
+ * @param imageId Identifier for the image
+ * @param description Optional description
+ * @returns Result with success status and metadata
+ */
+export async function addImageFromPaste(projectPath, pastedData, imageId, description) {
+    const detected = detectPastedImage(pastedData);
+    if (!detected.detected || !detected.buffer) {
+        return { success: false, error: detected.error || 'No image data detected in pasted content' };
+    }
+    try {
+        // Ensure images directory exists
+        const imagesDir = getImagesDir(projectPath);
+        await mkdir(imagesDir, { recursive: true });
+        // Create storage path
+        const ext = detected.extension || '.png';
+        const storagePath = getImageStoragePath(imageId, ext);
+        const destPath = join(imagesDir, storagePath);
+        // Write file
+        await writeFile(destPath, detected.buffer);
+        // Create metadata
+        const metadata = {
+            id: sanitizeImageId(imageId),
+            originalName: `pasted-image${ext}`,
+            storagePath,
+            mimeType: detected.mimeType || 'application/octet-stream',
+            size: detected.buffer.length,
+            description,
+            source: 'paste',
+            createdAt: new Date().toISOString(),
+        };
+        // Save to state
+        await saveImageMetadata(projectPath, metadata);
+        return { success: true, metadata };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}
+/**
+ * Check if input looks like it might contain pasted image data
+ * This is a quick check before doing full detection
+ */
+export function mightBePastedImage(input) {
+    if (!input || input.length < 50) {
+        return false;
+    }
+    // Check for data URL
+    if (input.startsWith('data:image/')) {
+        return true;
+    }
+    // Check for iTerm2 sequence
+    if (input.includes('\x1b]1337;File=')) {
+        return true;
+    }
+    // Check for long base64-looking string (at least 100 chars of mostly base64 alphabet)
+    const trimmed = input.trim();
+    if (trimmed.length >= 100 && /^[A-Za-z0-9+/=]+$/.test(trimmed)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Generate a unique image ID for pasted images
+ * Format: paste-{timestamp}-{random}
+ */
+export function generatePasteImageId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).slice(2, 6);
+    return `paste-${timestamp}-${random}`;
+}
+//# sourceMappingURL=imageManager.js.map