ai-pp3/dist/file-operations/file-handlers.js

CLI tool combining multimodal AI analysis with RawTherapee's engine to generate optimized PP3 profiles for RAW photography

// File operation functionality extracted from agent.ts
import fs from "node:fs";
import path from "node:path";
import { handleFileError, validateFileAccess } from "../utils/validation.js";
import { convertDngToImage, convertDngToImageWithPP3, } from "../raw-therapee-wrap.js";
/**
 * Reads image data from a file
 */
export async function readImageData(previewPath, verbose) {
    try {
        const imageData = await fs.promises.readFile(previewPath);
        if (verbose)
            console.log("Preview file read successfully");
        return imageData;
    }
    catch (error) {
        handleFileError(error, previewPath, "read");
        throw new Error("Failed to read preview image data");
    }
}
/**
 * Reads PP3 content from a file
 */
export async function readBasePP3Content(basePP3Path, verbose) {
    try {
        const content = await fs.promises.readFile(basePP3Path, "utf8");
        if (verbose)
            console.log(`Base PP3 file read successfully from ${basePP3Path}`);
        return content;
    }
    catch (error) {
        handleFileError(error, basePP3Path, "read");
        return undefined;
    }
}
/**
 * Creates a preview image from a RAW file
 */
export async function createPreviewImage({ inputPath, previewPath, basePP3Path, quality, format = "jpeg", verbose, }) {
    try {
        await (basePP3Path
            ? convertDngToImageWithPP3({
                input: inputPath,
                output: previewPath,
                pp3Path: basePP3Path,
                format,
                quality,
            })
            : convertDngToImage({
                input: inputPath,
                output: previewPath,
                format,
                quality,
            }));
        if (verbose)
            console.log(`Preview file created at ${previewPath}`);
        return true;
    }
    catch (error) {
        if (error instanceof Error)
            throw error;
        throw new Error("Unknown error creating preview image");
    }
}
/**
 * Sets up preview image and validates file access
 */
export async function setupPreviewAndValidation(inputPath, previewPath, basePP3Path, previewQuality, previewFormat, verbose) {
    await validateFileAccess(inputPath, "read");
    await validateFileAccess(path.dirname(previewPath), "write");
    if (verbose)
        console.log(`Generating preview with quality=${String(previewQuality)}`);
    const previewCreated = await createPreviewImage({
        inputPath,
        previewPath,
        basePP3Path,
        quality: previewQuality,
        format: previewFormat,
        verbose,
    });
    const finalBasePP3Path = basePP3Path ?? `${previewPath}.pp3`;
    return { previewCreated, finalBasePP3Path };
}
/**
 * Cleans up preview files if needed
 */
export async function cleanupPreviewFiles(previewPath, previewCreated, keepPreview, verbose) {
    if (!previewCreated || keepPreview) {
        return;
    }
    try {
        await fs.promises.unlink(previewPath);
        await fs.promises.unlink(`${previewPath}.pp3`);
        if (verbose)
            console.log("Preview file cleaned up");
    }
    catch (cleanupError) {
        if (cleanupError instanceof Error && "code" in cleanupError && verbose) {
            if (cleanupError.code === "ENOENT") {
                console.warn("Preview file was already deleted");
            }
            else if (cleanupError.code === "EACCES") {
                console.warn("Permission denied deleting preview file:", cleanupError.message);
            }
            else {
                console.warn("Failed to clean up preview file:", cleanupError.message);
            }
        }
    }
}
//# sourceMappingURL=file-handlers.js.map