simple-photo-gallery 0.0.3 → 0.0.5

package/dist/src/index.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-import process from 'node:process';
-import { Command } from 'commander';
-import { build } from './modules/build';
-import { init } from './modules/init';
-import { thumbnails } from './modules/thumbnails';
-const program = new Command();
-program.name('gallery').description('Simple Photo Gallery CLI').version('0.0.1');
-program
-    .command('init')
-    .description('Initialize a gallery by scaning a folder for images and videos')
-    .option('-p, --path <path>', 'Path where the gallery should be initialized. Default: current working directory', process.cwd())
-    .option('-o, --output <path>', 'Output directory for the gallery.json file', '')
-    .option('-r, --recursive', 'Scan subdirectories recursively', false)
-    .action(init);
-program
-    .command('thumbnails')
-    .description('Create thumbnails for all media files in the gallery')
-    .option('-p, --path <path>', 'Path to the folder containing the gallery.json file. Default: current working directory', process.cwd())
-    .option('-s, --size <size>', 'Thumbnail height in pixels', '200')
-    .option('-r, --recursive', 'Scan subdirectories recursively', false)
-    .action(thumbnails);
-program
-    .command('build')
-    .description('Build the HTML gallery in the specified directory')
-    .option('-p, --path <path>', 'Path to the folder containing the gallery.json file. Default: current working directory', process.cwd())
-    .option('-r, --recursive', 'Scan subdirectories recursively', false)
-    .action(build);
-program.parse();

package/dist/src/modules/build/index.js

@@ -1,57 +0,0 @@
-import { execSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-import { findGalleries } from '../../utils';
-function buildGallery(galleryDir, templateDir) {
-    // Make sure the gallery.json file exists
-    const galleryJsonPath = path.join(galleryDir, 'gallery', 'gallery.json');
-    if (!fs.existsSync(galleryJsonPath)) {
-        console.log(`No gallery/gallery.json found in ${galleryDir}`);
-        return;
-    }
-    // Build the template
-    const originalEnv = { ...process.env };
-    try {
-        // Set the environment variable for the gallery.json path that will be used by the template
-        process.env.GALLERY_JSON_PATH = galleryJsonPath;
-        process.env.GALLERY_OUTPUT_DIR = path.join(galleryDir, 'gallery');
-        execSync('yarn build', { cwd: templateDir, stdio: 'inherit' });
-    }
-    catch (error) {
-        console.error(error);
-        console.error(`Build failed for ${galleryDir}`);
-        return;
-    }
-    finally {
-        // Restore original environment and gallery.json
-        process.env = originalEnv;
-    }
-    // Copy the build output to the output directory
-    const outputDir = path.join(galleryDir, 'gallery');
-    const buildDir = path.join(outputDir, '_build');
-    fs.cpSync(buildDir, outputDir, { recursive: true });
-    // Move the index.html to the gallery directory
-    fs.copyFileSync(path.join(outputDir, 'index.html'), path.join(galleryDir, 'index.html'));
-    fs.rmSync(path.join(outputDir, 'index.html'));
-    // Clean up the _build directory
-    console.log('Cleaning up build directory...');
-    fs.rmSync(buildDir, { recursive: true, force: true });
-}
-export async function build(options) {
-    // Get the template directory
-    // Resolve the theme-modern package directory
-    const themePath = await import.meta.resolve('@simple-photo-gallery/theme-modern/package.json');
-    const themeDir = path.dirname(new URL(themePath).pathname);
-    // Find all gallery directories
-    const galleryDirs = findGalleries(options.path, options.recursive);
-    // If no galleries are found, exit
-    if (galleryDirs.length === 0) {
-        console.log('No gallery/gallery.json files found.');
-        return;
-    }
-    // Process each gallery
-    for (const dir of galleryDirs) {
-        buildGallery(path.resolve(dir), themeDir);
-    }
-}

package/dist/src/modules/build/types/index.js

@@ -1 +0,0 @@
-export {};

package/dist/src/modules/build/utils/index.js

@@ -1,7 +0,0 @@
-import path from 'node:path';
-// __dirname workaround for ESM modules
-const __dirname = path.dirname(new URL(import.meta.url).pathname);
-// Helper function to resolve paths relative to current file
-export const resolveFromCurrentDir = (...segments) => {
-    return path.resolve(__dirname, ...segments);
-};

package/dist/src/modules/init/const/index.js

@@ -1,4 +0,0 @@
-// Image extensions
-export const IMAGE_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.tiff', '.tif', '.svg']);
-// Video extensions
-export const VIDEO_EXTENSIONS = new Set(['.mp4', '.avi', '.mov', '.wmv', '.flv', '.webm', '.mkv', '.m4v', '.3gp']);

package/dist/src/modules/init/index.js

@@ -1,156 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { capitalizeTitle, getImageMetadata, getVideoDimensions, isMediaFile } from './utils';
-async function scanDirectory(dirPath) {
-    const mediaFiles = [];
-    try {
-        const entries = await fs.readdir(dirPath, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isFile()) {
-                const fullPath = path.join(dirPath, entry.name);
-                const mediaType = isMediaFile(entry.name);
-                if (mediaType) {
-                    console.log(`Processing ${mediaType}: ${entry.name}`);
-                    let metadata = { width: 0, height: 0 };
-                    try {
-                        if (mediaType === 'image') {
-                            metadata = await getImageMetadata(fullPath);
-                        }
-                        else if (mediaType === 'video') {
-                            try {
-                                const videoDimensions = await getVideoDimensions(fullPath);
-                                metadata = { ...videoDimensions };
-                            }
-                            catch (videoError) {
-                                if (typeof videoError === 'object' &&
-                                    videoError !== null &&
-                                    'message' in videoError &&
-                                    typeof videoError.message === 'string' &&
-                                    (videoError.message.includes('ffprobe') ||
-                                        videoError.message.includes('ffmpeg'))) {
-                                    console.error(`Error: ffprobe (part of ffmpeg) is required to process videos. Please install ffmpeg and ensure it is available in your PATH. Skipping video: ${entry.name}`);
-                                }
-                                else {
-                                    console.error(`Error processing video ${entry.name}:`, videoError);
-                                }
-                                continue; // Skip this file
-                            }
-                        }
-                    }
-                    catch (mediaError) {
-                        console.error(`Error processing file ${entry.name}:`, mediaError);
-                        continue; // Skip this file
-                    }
-                    const mediaFile = {
-                        type: mediaType,
-                        path: fullPath,
-                        width: metadata.width,
-                        height: metadata.height,
-                    };
-                    if (metadata.description) {
-                        mediaFile.alt = metadata.description;
-                    }
-                    mediaFiles.push(mediaFile);
-                }
-            }
-        }
-    }
-    catch (error) {
-        console.error(`Error scanning directory ${dirPath}:`, error);
-    }
-    return mediaFiles;
-}
-async function createGalleryJson(mediaFiles, galleryJsonPath, subGalleries = []) {
-    const galleryDir = path.dirname(galleryJsonPath);
-    // Convert media file paths to be relative to gallery.json
-    const relativeMediaFiles = mediaFiles.map((file) => ({
-        ...file,
-        path: path.relative(galleryDir, file.path),
-    }));
-    // Convert subGallery header image paths to be relative to gallery.json
-    const relativeSubGalleries = subGalleries.map((subGallery) => ({
-        ...subGallery,
-        headerImage: subGallery.headerImage ? path.relative(galleryDir, subGallery.headerImage) : '',
-    }));
-    const galleryData = {
-        title: 'My Gallery',
-        description: 'My gallery with fantastic photos.',
-        headerImage: relativeMediaFiles[0]?.path || '',
-        metadata: { ogUrl: '' },
-        sections: [
-            {
-                images: relativeMediaFiles,
-            },
-        ],
-        subGalleries: {
-            title: 'Sub Galleries',
-            galleries: relativeSubGalleries,
-        },
-    };
-    await fs.writeFile(galleryJsonPath, JSON.stringify(galleryData, null, 2));
-}
-async function processDirectory(dirPath, options) {
-    let totalFiles = 0;
-    const subGalleries = [];
-    // Scan current directory for media files
-    const mediaFiles = await scanDirectory(dirPath);
-    totalFiles += mediaFiles.length;
-    // Process subdirectories only if recursive mode is enabled
-    if (options.recursive) {
-        try {
-            const entries = await fs.readdir(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isDirectory() && entry.name !== 'gallery') {
-                    const subDirPath = path.join(dirPath, entry.name);
-                    const result = await processDirectory(subDirPath, options);
-                    totalFiles += result.totalFiles;
-                    // If the subdirectory had media files, add it as a subGallery
-                    if (result.subGallery) {
-                        subGalleries.push(result.subGallery);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error(`Error reading directory ${dirPath}:`, error);
-        }
-    }
-    // Create gallery.json if there are media files or subGalleries
-    if (mediaFiles.length > 0 || subGalleries.length > 0) {
-        const outputPath = options.output
-            ? path.resolve(options.output, path.relative(path.resolve(options.path), dirPath), 'gallery')
-            : path.join(dirPath, 'gallery');
-        const galleryJsonPath = path.join(outputPath, 'gallery.json');
-        // Create output directory
-        await fs.mkdir(outputPath, { recursive: true });
-        // Create gallery.json for this directory
-        await createGalleryJson(mediaFiles, galleryJsonPath, subGalleries);
-        console.log(`Gallery JSON created at: ${galleryJsonPath} (${mediaFiles.length} files, ${subGalleries.length} subgalleries)`);
-    }
-    // Return result with suGgallery info if this directory has media files
-    const result = { totalFiles };
-    if (mediaFiles.length > 0 || subGalleries.length > 0) {
-        const dirName = path.basename(dirPath);
-        result.subGallery = {
-            title: capitalizeTitle(dirName),
-            headerImage: mediaFiles[0]?.path || '',
-            path: path.join('..', dirName),
-        };
-    }
-    return result;
-}
-export async function init(options) {
-    const scanPath = path.resolve(options.path);
-    console.log(`Scanning directory: ${scanPath}`);
-    console.log(`Recursive: ${options.recursive}`);
-    try {
-        // Ensure scan path exists
-        await fs.access(scanPath);
-        // Process the directory tree with the specified recursion setting
-        const result = await processDirectory(scanPath, options);
-        console.log(`Total files processed: ${result.totalFiles}`);
-    }
-    catch (error) {
-        throw new Error(`Error during scan: ${error}`);
-    }
-}

package/dist/src/modules/init/types/index.js

@@ -1 +0,0 @@
-export {};

package/dist/src/modules/init/utils/index.js

@@ -1,93 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import exifReader from 'exif-reader';
-import ffprobe from 'node-ffprobe';
-import sharp from 'sharp';
-import { IMAGE_EXTENSIONS, VIDEO_EXTENSIONS } from '../const';
-export async function getImageMetadata(filePath) {
-    try {
-        const metadata = await sharp(filePath).metadata();
-        let description;
-        // Extract description from EXIF data
-        if (metadata.exif) {
-            try {
-                const exifData = exifReader(metadata.exif);
-                if (exifData.Image?.ImageDescription) {
-                    description = exifData.Image.ImageDescription;
-                }
-                else if (exifData.Image?.Description) {
-                    description = exifData.Image.Description.toString();
-                }
-            }
-            catch {
-                // EXIF parsing failed, but that's OK
-            }
-        }
-        return {
-            width: metadata.width || 0,
-            height: metadata.height || 0,
-            description,
-        };
-    }
-    catch (error) {
-        console.warn(`Warning: Could not get metadata for image ${filePath}:`, error);
-        return { width: 0, height: 0 };
-    }
-}
-export async function getVideoDimensions(filePath) {
-    try {
-        const data = await ffprobe(filePath);
-        const videoStream = data.streams.find((stream) => stream.codec_type === 'video');
-        if (videoStream) {
-            return {
-                width: videoStream.width || 0,
-                height: videoStream.height || 0,
-            };
-        }
-        return { width: 0, height: 0 };
-    }
-    catch (error) {
-        console.warn(`Warning: Could not get dimensions for video ${filePath}:`, error);
-        return { width: 0, height: 0 };
-    }
-}
-export function isMediaFile(fileName) {
-    const ext = path.extname(fileName).toLowerCase();
-    if (IMAGE_EXTENSIONS.has(ext))
-        return 'image';
-    if (VIDEO_EXTENSIONS.has(ext))
-        return 'video';
-    return null;
-}
-export function capitalizeTitle(folderName) {
-    return folderName
-        .replace('-', ' ')
-        .replace('_', ' ')
-        .split(' ')
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join(' ');
-}
-export async function hasMediaFiles(dirPath) {
-    try {
-        const entries = await fs.readdir(dirPath, { withFileTypes: true });
-        // Check for media files in current directory
-        for (const entry of entries) {
-            if (entry.isFile() && isMediaFile(entry.name)) {
-                return true;
-            }
-        }
-        // Check subdirectories recursively
-        for (const entry of entries) {
-            if (entry.isDirectory() && entry.name !== 'gallery') {
-                const subDirPath = path.join(dirPath, entry.name);
-                if (await hasMediaFiles(subDirPath)) {
-                    return true;
-                }
-            }
-        }
-    }
-    catch (error) {
-        console.error(`Error checking for media files in ${dirPath}:`, error);
-    }
-    return false;
-}

package/dist/src/modules/thumbnails/index.js

@@ -1,98 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { createImageThumbnail, createVideoThumbnail } from './utils';
-import { GalleryDataSchema } from '../../types';
-import { findGalleries } from '../../utils';
-const processGallery = async (galleryDir, size) => {
-    const galleryJsonPath = path.join(galleryDir, 'gallery', 'gallery.json');
-    const thumbnailsPath = path.join(galleryDir, 'gallery', 'thumbnails');
-    console.log(`\nProcessing gallery in: ${galleryDir}`);
-    try {
-        // Ensure thumbnails directory exists
-        fs.mkdirSync(thumbnailsPath, { recursive: true });
-        // Read gallery.json
-        const galleryContent = fs.readFileSync(galleryJsonPath, 'utf8');
-        const galleryData = GalleryDataSchema.parse(JSON.parse(galleryContent));
-        // Process all sections and their images
-        let processedCount = 0;
-        for (const section of galleryData.sections) {
-            for (const [index, mediaFile] of section.images.entries()) {
-                section.images[index] = await processMediaFile(mediaFile, galleryDir, thumbnailsPath, size);
-            }
-            processedCount += section.images.length;
-        }
-        // Write updated gallery.json
-        fs.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
-        return processedCount;
-    }
-    catch (error) {
-        console.error(`Error creating thumbnails for ${galleryDir}:`, error);
-        return 0;
-    }
-};
-async function processMediaFile(mediaFile, galleryDir, thumbnailsPath, size) {
-    try {
-        // Resolve the path relative to the gallery.json file location, not the gallery directory
-        const galleryJsonDir = path.join(galleryDir, 'gallery');
-        const filePath = path.resolve(path.join(galleryJsonDir, mediaFile.path));
-        const fileName = path.basename(filePath);
-        const fileNameWithoutExt = path.parse(fileName).name;
-        const thumbnailFileName = `${fileNameWithoutExt}.jpg`;
-        const thumbnailPath = path.join(thumbnailsPath, thumbnailFileName);
-        const relativeThumbnailPath = path.relative(galleryJsonDir, thumbnailPath);
-        console.log(`Processing ${mediaFile.type}: ${fileName}`);
-        let thumbnailDimensions;
-        if (mediaFile.type === 'image') {
-            thumbnailDimensions = await createImageThumbnail(filePath, thumbnailPath, size);
-        }
-        else if (mediaFile.type === 'video') {
-            thumbnailDimensions = await createVideoThumbnail(filePath, thumbnailPath, size);
-        }
-        else {
-            console.warn(`Unknown media type: ${mediaFile.type}, skipping...`);
-            return mediaFile;
-        }
-        // Update media file with thumbnail information
-        const updatedMediaFile = {
-            ...mediaFile,
-            thumbnail: {
-                path: relativeThumbnailPath,
-                width: thumbnailDimensions.width,
-                height: thumbnailDimensions.height,
-            },
-        };
-        return updatedMediaFile;
-    }
-    catch (error) {
-        if (error instanceof Error && error.message === 'FFMPEG_NOT_AVAILABLE') {
-            console.warn(`⚠ Skipping video thumbnail (ffmpeg not available): ${path.basename(mediaFile.path)}`);
-        }
-        else {
-            console.error(`Error processing ${mediaFile.path}:`, error);
-        }
-        return mediaFile;
-    }
-}
-export async function thumbnails(options) {
-    const size = Number.parseInt(options.size);
-    // Find all gallery directories
-    const galleryDirs = findGalleries(options.path, options.recursive);
-    // If no galleries are found, exit
-    if (galleryDirs.length === 0) {
-        console.log('No gallery/gallery.json files found.');
-        return;
-    }
-    // Process each gallery directory
-    let totalProcessed = 0;
-    for (const galleryDir of galleryDirs) {
-        const processed = await processGallery(galleryDir, size);
-        totalProcessed += processed;
-    }
-    // Log processing stats
-    if (options.recursive) {
-        console.log(`Completed processing ${totalProcessed} total media files across ${galleryDirs.length} galleries.`);
-    }
-    else {
-        console.log(`Completed processing ${totalProcessed} media files.`);
-    }
-}

package/dist/src/modules/thumbnails/types/index.js

@@ -1 +0,0 @@
-export {};

package/dist/src/modules/thumbnails/utils/index.js

@@ -1,127 +0,0 @@
-import { spawn } from 'node:child_process';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import ffprobe from 'node-ffprobe';
-import sharp from 'sharp';
-// Check if ffmpeg is available
-async function checkFfmpegAvailability() {
-    return new Promise((resolve) => {
-        const ffmpeg = spawn('ffmpeg', ['-version']);
-        ffmpeg.on('close', (code) => {
-            resolve(code === 0);
-        });
-        ffmpeg.on('error', () => {
-            resolve(false);
-        });
-    });
-}
-// Utility function to resize and save thumbnail
-async function resizeAndSaveThumbnail(image, outputPath, width, height) {
-    await image.resize(width, height, { withoutEnlargement: true }).jpeg({ quality: 90 }).toFile(outputPath);
-}
-export async function createImageThumbnail(inputPath, outputPath, height) {
-    try {
-        // Check if input file exists
-        await fs.access(inputPath);
-        // Create thumbnail using sharp
-        const image = sharp(inputPath);
-        const metadata = await image.metadata();
-        const originalWidth = metadata.width || 0;
-        const originalHeight = metadata.height || 0;
-        if (originalWidth === 0 || originalHeight === 0) {
-            throw new Error('Invalid image dimensions');
-        }
-        // Calculate width maintaining aspect ratio
-        const aspectRatio = originalWidth / originalHeight;
-        const width = Math.round(height * aspectRatio);
-        await resizeAndSaveThumbnail(image, outputPath, width, height);
-        return { width, height };
-    }
-    catch (error) {
-        throw new Error(`Failed to create image thumbnail for ${inputPath}: ${error}`);
-    }
-}
-export async function createVideoThumbnail(inputPath, outputPath, height) {
-    try {
-        // Check if input file exists
-        await fs.access(inputPath);
-        // Check if ffmpeg is available
-        const ffmpegAvailable = await checkFfmpegAvailability();
-        if (!ffmpegAvailable) {
-            console.warn(`Warning: ffmpeg is not available. Skipping thumbnail creation for video: ${path.basename(inputPath)}`);
-            throw new Error('FFMPEG_NOT_AVAILABLE');
-        }
-        // Get video metadata using ffprobe
-        const videoData = await ffprobe(inputPath);
-        const videoStream = videoData.streams.find((stream) => stream.codec_type === 'video');
-        if (!videoStream) {
-            throw new Error('No video stream found');
-        }
-        const originalWidth = videoStream.width || 0;
-        const originalHeight = videoStream.height || 0;
-        if (originalWidth === 0 || originalHeight === 0) {
-            throw new Error('Invalid video dimensions');
-        }
-        // Calculate width maintaining aspect ratio
-        const aspectRatio = originalWidth / originalHeight;
-        const width = Math.round(height * aspectRatio);
-        // Use ffmpeg to extract first frame as a temporary file, then process with sharp
-        const tempFramePath = `${outputPath}.temp.png`;
-        return new Promise((resolve, reject) => {
-            // Extract first frame using ffmpeg
-            const ffmpeg = spawn('ffmpeg', [
-                '-i',
-                inputPath,
-                '-vframes',
-                '1',
-                '-y', // Overwrite output file
-                tempFramePath,
-            ]);
-            ffmpeg.stderr.on('data', (data) => {
-                // FFmpeg writes normal output to stderr, so we don't treat this as an error
-                console.debug(`ffmpeg: ${data.toString()}`);
-            });
-            ffmpeg.on('close', async (code) => {
-                if (code === 0) {
-                    try {
-                        // Process the extracted frame with sharp
-                        const frameImage = sharp(tempFramePath);
-                        await resizeAndSaveThumbnail(frameImage, outputPath, width, height);
-                        // Clean up temporary file
-                        try {
-                            await fs.unlink(tempFramePath);
-                        }
-                        catch {
-                            // Ignore cleanup errors
-                        }
-                        resolve({ width, height });
-                    }
-                    catch (sharpError) {
-                        reject(new Error(`Failed to process extracted frame: ${sharpError}`));
-                    }
-                }
-                else {
-                    reject(new Error(`ffmpeg exited with code ${code}`));
-                }
-            });
-            ffmpeg.on('error', (error) => {
-                reject(new Error(`Failed to start ffmpeg: ${error.message}`));
-            });
-        });
-    }
-    catch (error) {
-        if (error instanceof Error && error.message === 'FFMPEG_NOT_AVAILABLE') {
-            // Re-throw the specific error for graceful handling upstream
-            throw error;
-        }
-        if (typeof error === 'object' &&
-            error !== null &&
-            'message' in error &&
-            typeof error.message === 'string' &&
-            (error.message.includes('ffmpeg') ||
-                error.message.includes('ffprobe'))) {
-            throw new Error(`Error: ffmpeg is required to process videos. Please install ffmpeg and ensure it is available in your PATH. Failed to process: ${path.basename(inputPath)}`);
-        }
-        throw new Error(`Failed to create video thumbnail for ${inputPath}: ${error}`);
-    }
-}

package/dist/src/types/index.js

@@ -1,35 +0,0 @@
-import { z } from 'zod';
-export const ThumbnailSchema = z.object({
-    path: z.string(),
-    width: z.number(),
-    height: z.number(),
-});
-export const MediaFileSchema = z.object({
-    type: z.enum(['image', 'video']),
-    path: z.string(),
-    alt: z.string().optional(),
-    width: z.number(),
-    height: z.number(),
-    thumbnail: ThumbnailSchema.optional(),
-});
-export const GallerySectionSchema = z.object({
-    title: z.string().optional(),
-    description: z.string().optional(),
-    images: z.array(MediaFileSchema),
-});
-export const SubGallerySchema = z.object({
-    title: z.string(),
-    headerImage: z.string(),
-    path: z.string(),
-});
-export const GalleryDataSchema = z.object({
-    title: z.string(),
-    description: z.string(),
-    headerImage: z.string(),
-    metadata: z.object({
-        ogUrl: z.string(),
-    }),
-    galleryOutputPath: z.string().optional(),
-    sections: z.array(GallerySectionSchema),
-    subGalleries: z.object({ title: z.string(), galleries: z.array(SubGallerySchema) }),
-});

package/dist/src/utils/index.js

@@ -1,34 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-/**
- * Finds all gallery directories that contain a gallery/gallery.json file.
- *
- * @param basePath - The base directory to search from
- * @param recursive - Whether to search subdirectories recursively
- * @returns Array of paths to directories containing gallery/gallery.json files
- */
-export const findGalleries = (basePath, recursive) => {
-    const galleryDirs = [];
-    // Check basePath itself
-    const galleryJsonPath = path.join(basePath, 'gallery', 'gallery.json');
-    if (fs.existsSync(galleryJsonPath)) {
-        galleryDirs.push(basePath);
-    }
-    // If recursive, search all subdirectories
-    if (recursive) {
-        try {
-            const entries = fs.readdirSync(basePath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isDirectory() && entry.name !== 'gallery') {
-                    const subPath = path.join(basePath, entry.name);
-                    const subResults = findGalleries(subPath, recursive);
-                    galleryDirs.push(...subResults);
-                }
-            }
-        }
-        catch {
-            // Silently ignore errors when reading directories
-        }
-    }
-    return galleryDirs;
-};