mulmocast 0.0.2 → 0.0.4

package/lib/actions/movie.js

@@ -2,56 +2,115 @@ import ffmpeg from "fluent-ffmpeg";
 import { GraphAILogger } from "graphai";
 import { MulmoScriptMethods } from "../methods/index.js";
 import { getAudioArtifactFilePath, getOutputVideoFilePath, writingMessage } from "../utils/file.js";
+const isMac = process.platform === "darwin";
+const videoCodec = isMac ? "h264_videotoolbox" : "libx264";
+export const getVideoPart = (inputIndex, mediaType, duration, canvasInfo) => {
+    const videoId = `v${inputIndex}`;
+    return {
+        videoId,
+        videoPart: `[${inputIndex}:v]` +
+            [
+                mediaType === "image" ? "loop=loop=-1:size=1:start=0" : "",
+                `trim=duration=${duration}`,
+                "fps=30",
+                "setpts=PTS-STARTPTS",
+                `scale=${canvasInfo.width}:${canvasInfo.height}`,
+                "setsar=1",
+                "format=yuv420p",
+            ]
+                .filter((a) => a)
+                .join(",") +
+            `[${videoId}]`,
+    };
+};
+export const getAudioPart = (inputIndex, duration, delay) => {
+    const audioId = `a${inputIndex}`;
+    return {
+        audioId,
+        audioPart: `[${inputIndex}:a]` +
+            `atrim=duration=${duration},` + // Trim to beat duration
+            `adelay=${delay}|${delay},` +
+            `aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo` +
+            `[${audioId}]`,
+    };
+};
+const getOutputOption = (audioId) => {
+    return [
+        "-preset veryfast", // Faster encoding
+        "-map [v]", // Map the video stream
+        `-map ${audioId}`, // Map the audio stream
+        `-c:v ${videoCodec}`, // Set video codec
+        "-threads 8",
+        "-filter_threads 8",
+        "-b:v 5M", // bitrate (only for videotoolbox)
+        "-bufsize",
+        "10M", // Add buffer size for better quality
+        "-maxrate",
+        "7M", // Maximum bitrate
+        "-r 30", // Set frame rate
+        "-pix_fmt yuv420p", // Set pixel format for better compatibility
+    ];
+};
 const createVideo = (audioArtifactFilePath, outputVideoPath, studio) => {
     return new Promise((resolve, reject) => {
         const start = performance.now();
-        let command = ffmpeg();
+        const ffmpegContext = {
+            command: ffmpeg(),
+            inputCount: 0,
+        };
+        function addInput(input) {
+            ffmpegContext.command = ffmpegContext.command.input(input);
+            ffmpegContext.inputCount++;
+            return ffmpegContext.inputCount - 1; // returned the index of the input
+        }
         if (studio.beats.some((beat) => !beat.imageFile)) {
             GraphAILogger.info("beat.imageFile is not set. Please run `yarn run images ${file}` ");
             return;
         }
-        // Add each image input
-        studio.beats.forEach((beat) => {
-            command = command.input(beat.imageFile); // HACK
-        });
-        const imageCount = studio.beats.length;
         const canvasInfo = MulmoScriptMethods.getCanvasSize(studio.script);
+        const padding = MulmoScriptMethods.getPadding(studio.script) / 1000;
+        // Add each image input
         const filterComplexParts = [];
-        studio.beats.forEach((beat, index) => {
-            // Resize background image to match canvas dimensions
-            const duration = beat.duration + (index === 0 ? MulmoScriptMethods.getPadding(studio.script) / 1000 : 0);
-            const parts = `[${index}:v]loop=loop=-1:size=1:start=0,` +
-                `trim=duration=${duration},` +
-                `fps=30,` +
-                `setpts=PTS-STARTPTS,` +
-                `scale=${canvasInfo.width}:${canvasInfo.height},` +
-                `setsar=1,format=yuv420p` +
-                `[v${index}]`;
-            // console.log(parts);
-            filterComplexParts.push(parts);
-        });
+        const filterComplexVideoIds = [];
+        const filterComplexAudioIds = [];
+        studio.beats.reduce((timestamp, beat, index) => {
+            if (!beat.imageFile || !beat.duration) {
+                throw new Error(`beat.imageFile is not set: index=${index}`);
+            }
+            const inputIndex = addInput(beat.imageFile);
+            const mediaType = MulmoScriptMethods.getImageType(studio.script, studio.script.beats[index]);
+            const headOrTail = index === 0 || index === studio.beats.length - 1;
+            const duration = beat.duration + (headOrTail ? padding : 0);
+            const { videoId, videoPart } = getVideoPart(inputIndex, mediaType, duration, canvasInfo);
+            filterComplexVideoIds.push(videoId);
+            filterComplexParts.push(videoPart);
+            if (mediaType === "movie") {
+                const { audioId, audioPart } = getAudioPart(inputIndex, duration, timestamp * 1000);
+                filterComplexAudioIds.push(audioId);
+                filterComplexParts.push(audioPart);
+            }
+            return timestamp + duration;
+        }, 0);
+        // console.log("*** images", images.audioIds);
         // Concatenate the trimmed images
-        const concatInput = studio.beats.map((_, index) => `[v${index}]`).join("");
-        filterComplexParts.push(`${concatInput}concat=n=${imageCount}:v=1:a=0[v]`);
+        filterComplexParts.push(`${filterComplexVideoIds.map((id) => `[${id}]`).join("")}concat=n=${studio.beats.length}:v=1:a=0[v]`);
+        const audioIndex = addInput(audioArtifactFilePath); // Add audio input
+        const artifactAudioId = `${audioIndex}:a`;
+        const ffmpegContextAudioId = (() => {
+            if (filterComplexAudioIds.length > 0) {
+                const mainAudioId = "mainaudio";
+                const compositeAudioId = "composite";
+                const audioIds = filterComplexAudioIds.map((id) => `[${id}]`).join("");
+                filterComplexParts.push(`[${artifactAudioId}]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo[${mainAudioId}]`);
+                filterComplexParts.push(`[${mainAudioId}]${audioIds}amix=inputs=${filterComplexAudioIds.length + 1}:duration=first:dropout_transition=2[${compositeAudioId}]`);
+                return `[${compositeAudioId}]`; // notice that we need to use [mainaudio] instead of mainaudio
+            }
+            return artifactAudioId;
+        })();
         // Apply the filter complex for concatenation and map audio input
-        command
+        ffmpegContext.command
             .complexFilter(filterComplexParts)
-            .input(audioArtifactFilePath) // Add audio input
-            .outputOptions([
-            "-preset veryfast", // Faster encoding
-            "-map [v]", // Map the video stream
-            `-map ${imageCount /* + captionCount*/}:a`, // Map the audio stream (audio is the next input after all images)
-            "-c:v h264_videotoolbox", // Set video codec
-            "-threads 8",
-            "-filter_threads 8",
-            "-b:v 5M", // bitrate (only for videotoolbox)
-            "-bufsize",
-            "10M", // Add buffer size for better quality
-            "-maxrate",
-            "7M", // Maximum bitrate
-            "-r 30", // Set frame rate
-            "-pix_fmt yuv420p", // Set pixel format for better compatibility
-        ])
+            .outputOptions(getOutputOption(ffmpegContextAudioId))
             .on("start", (__cmdLine) => {
             GraphAILogger.log("Started FFmpeg ..."); // with command:', cmdLine);
         })

package/lib/actions/pdf.d.ts

@@ -0,0 +1,2 @@
+import { MulmoStudioContext, PDFMode, PDFSize } from "../types/index.js";
+export declare const pdf: (context: MulmoStudioContext, pdfMode: PDFMode, pdfSize: PDFSize) => Promise<void>;

package/lib/actions/pdf.js

@@ -0,0 +1,211 @@
+import fs from "fs";
+import path from "path";
+import { rgb, PDFDocument } from "pdf-lib";
+import fontkit from "@pdf-lib/fontkit";
+import { chunkArray, isHttp } from "../utils/utils.js";
+import { getOutputPdfFilePath, writingMessage } from "../utils/file.js";
+import { MulmoScriptMethods } from "../methods/index.js";
+import { fontSize, textMargin, drawSize, wrapText } from "../utils/pdf.js";
+const imagesPerPage = 4;
+const offset = 10;
+const handoutImageRatio = 0.5;
+const readImage = async (imagePath, pdfDoc) => {
+    const imageBytes = await (async () => {
+        if (isHttp(imagePath)) {
+            const res = await fetch(imagePath);
+            const arrayBuffer = await res.arrayBuffer();
+            return Buffer.from(arrayBuffer);
+        }
+        return fs.readFileSync(imagePath);
+    })();
+    const ext = path.extname(imagePath).toLowerCase();
+    return ext === ".jpg" || ext === ".jpeg" ? await pdfDoc.embedJpg(imageBytes) : await pdfDoc.embedPng(imageBytes);
+};
+const pdfSlide = async (pageWidth, pageHeight, imagePaths, pdfDoc) => {
+    const cellRatio = pageHeight / pageWidth;
+    for (const imagePath of imagePaths) {
+        const image = await readImage(imagePath, pdfDoc);
+        const { width: origWidth, height: origHeight } = image.scale(1);
+        const originalRatio = origHeight / origWidth;
+        const fitWidth = originalRatio / cellRatio < 1;
+        const { drawWidth, drawHeight } = drawSize(fitWidth, pageWidth, pageHeight, origWidth, origHeight);
+        const page = pdfDoc.addPage([pageWidth, pageHeight]);
+        page.drawImage(image, {
+            x: 0,
+            y: 0,
+            width: drawWidth,
+            height: drawHeight,
+        });
+    }
+};
+const pdfTalk = async (pageWidth, pageHeight, imagePaths, texts, pdfDoc, font) => {
+    const imageRatio = 0.7;
+    const textMargin = 8;
+    const textY = pageHeight * (1 - imageRatio) - textMargin;
+    const targetWidth = pageWidth - offset;
+    const targetHeight = pageHeight * imageRatio - offset;
+    const cellRatio = targetHeight / targetWidth;
+    for (const [index, imagePath] of imagePaths.entries()) {
+        const text = texts[index];
+        const image = await readImage(imagePath, pdfDoc);
+        const { width: origWidth, height: origHeight } = image.scale(1);
+        const originalRatio = origHeight / origWidth;
+        const fitWidth = originalRatio / cellRatio < 1;
+        const { drawWidth, drawHeight } = drawSize(fitWidth, targetWidth, targetHeight, origWidth, origHeight);
+        const x = (pageWidth - drawWidth) / 2;
+        const y = pageHeight - drawHeight - offset;
+        const page = pdfDoc.addPage([pageWidth, pageHeight]);
+        const pos = {
+            x,
+            y,
+            width: drawWidth,
+            height: drawHeight,
+        };
+        page.drawImage(image, pos);
+        page.drawRectangle({
+            ...pos,
+            borderColor: rgb(0, 0, 0),
+            borderWidth: 1,
+        });
+        const lines = wrapText(text, font, fontSize, pageWidth - textMargin * 2);
+        for (const [index, line] of lines.entries()) {
+            page.drawText(line, {
+                x: textMargin,
+                y: textY - fontSize - (fontSize + 2) * index,
+                size: fontSize,
+                color: rgb(0, 0, 0),
+                maxWidth: pageWidth - 2 * textMargin,
+                font,
+            });
+        }
+    }
+};
+const pdfHandout = async (pageWidth, pageHeight, imagePaths, texts, pdfDoc, font, isLandscapeImage) => {
+    const cellRatio = (pageHeight / imagesPerPage - offset) / (pageWidth * handoutImageRatio - offset);
+    let index = 0;
+    for (const chunkPaths of chunkArray(imagePaths, imagesPerPage)) {
+        const page = pdfDoc.addPage([pageWidth, pageHeight]);
+        for (let i = 0; i < chunkPaths.length; i++) {
+            const imagePath = chunkPaths[i];
+            const image = await readImage(imagePath, pdfDoc);
+            const { width: origWidth, height: origHeight } = image.scale(1);
+            const originalRatio = origHeight / origWidth;
+            const fitWidth = originalRatio / cellRatio < 1;
+            const pos = (() => {
+                if (isLandscapeImage) {
+                    const cellHeight = pageHeight / imagesPerPage - offset;
+                    const { drawWidth, drawHeight } = drawSize(fitWidth, (pageWidth - offset) * handoutImageRatio, cellHeight - offset, origWidth, origHeight);
+                    const x = offset;
+                    const y = pageHeight - (i + 1) * cellHeight + (cellHeight - drawHeight) * handoutImageRatio;
+                    return {
+                        x,
+                        y,
+                        width: drawWidth,
+                        height: drawHeight,
+                    };
+                }
+                else {
+                    const cellWidth = pageWidth / imagesPerPage;
+                    const { drawWidth, drawHeight } = drawSize(fitWidth, cellWidth - offset, (pageHeight - offset) * handoutImageRatio, origWidth, origHeight);
+                    const x = pageWidth - (imagesPerPage - i) * cellWidth + (cellWidth - drawWidth) * handoutImageRatio;
+                    const y = pageHeight - drawHeight - offset;
+                    return {
+                        x,
+                        y,
+                        width: drawWidth,
+                        height: drawHeight,
+                    };
+                }
+            })();
+            page.drawRectangle({
+                ...pos,
+                borderColor: rgb(0, 0, 0),
+                borderWidth: 1,
+            });
+            page.drawImage(image, pos);
+            if (isLandscapeImage) {
+                const lines = wrapText(texts[index], font, fontSize, pos.width - textMargin * 2);
+                for (const [index, line] of lines.entries()) {
+                    page.drawText(line, {
+                        ...pos,
+                        x: pos.x + pos.width + textMargin,
+                        y: pos.y + pos.height - fontSize - (fontSize + 2) * index,
+                        size: fontSize,
+                        font,
+                    });
+                }
+                /*
+                page.drawRectangle({
+                  ...pos,
+                  x: pos.x +  pos.width ,
+                  borderColor: rgb(0, 0, 0),
+                  borderWidth: 1,
+                  });
+                */
+            }
+            else {
+                const lines = wrapText(texts[index], font, fontSize, pos.width - textMargin * 2);
+                for (const [index, line] of lines.entries()) {
+                    page.drawText(line, {
+                        ...pos,
+                        x: pos.x,
+                        y: textMargin + pos.height - fontSize - (fontSize + textMargin) * index - 2 * textMargin,
+                        size: fontSize,
+                        font,
+                    });
+                }
+                /*
+                page.drawRectangle({
+                  ...pos,
+                  x: pos.x,
+                  y: textMargin,
+                  height: pos.height - 2 * textMargin,
+                  borderColor: rgb(0, 0, 0),
+                  borderWidth: 1,
+                });
+                */
+            }
+            index = index + 1;
+        }
+    }
+};
+const outputSize = (pdfSize, isLandscapeImage, isRotate) => {
+    if (pdfSize === "a4") {
+        if (isLandscapeImage !== isRotate) {
+            return { width: 841.89, height: 595.28 };
+        }
+        return { width: 595.28, height: 841.89 };
+    }
+    // letter
+    if (isLandscapeImage !== isRotate) {
+        return { width: 792, height: 612 };
+    }
+    return { width: 612, height: 792 };
+};
+export const pdf = async (context, pdfMode, pdfSize) => {
+    const { studio, fileDirs } = context;
+    const { outDirPath } = fileDirs;
+    const { width: imageWidth, height: imageHeight } = MulmoScriptMethods.getCanvasSize(studio.script);
+    const isLandscapeImage = imageWidth > imageHeight;
+    const isRotate = pdfMode === "handout";
+    const { width: pageWidth, height: pageHeight } = outputSize(pdfSize, isLandscapeImage, isRotate);
+    const imagePaths = studio.beats.map((beat) => beat.imageFile);
+    const texts = studio.script.beats.map((beat) => beat.text);
+    const outputPdfPath = getOutputPdfFilePath(outDirPath, studio.filename, pdfMode);
+    const pdfDoc = await PDFDocument.create();
+    pdfDoc.registerFontkit(fontkit);
+    const fontBytes = fs.readFileSync("assets/font/NotoSansJP-Regular.ttf");
+    const customFont = await pdfDoc.embedFont(fontBytes);
+    if (pdfMode === "handout") {
+        await pdfHandout(pageWidth, pageHeight, imagePaths, texts, pdfDoc, customFont, isLandscapeImage);
+    }
+    if (pdfMode === "slide") {
+        await pdfSlide(pageWidth, pageHeight, imagePaths, pdfDoc);
+    }
+    if (pdfMode === "talk") {
+        await pdfTalk(pageWidth, pageHeight, imagePaths, texts, pdfDoc, customFont);
+    }
+    const pdfBytes = await pdfDoc.save();
+    fs.writeFileSync(outputPdfPath, pdfBytes);
+    writingMessage(outputPdfPath);
+};

package/lib/actions/translate.js

@@ -32,7 +32,8 @@ const translateGraph = {
             agent: "mapAgent",
             inputs: {
                 targetLangs: ":targetLangs",
-                rows: ":studio.beats",
+                studio: ":studio",
+                rows: ":studio.script.beats",
                 lang: ":lang",
             },
             params: {
@@ -42,12 +43,23 @@ const translateGraph = {
             graph: {
                 version: 0.5,
                 nodes: {
+                    studioBeat: {
+                        agent: (namedInputs) => {
+                            return namedInputs.rows[namedInputs.index];
+                        },
+                        inputs: {
+                            index: ":__mapIndex",
+                            rows: ":studio.beats",
+                        },
+                    },
                     preprocessBeats: {
                         agent: "mapAgent",
                         inputs: {
                             beat: ":beat",
+                            studioBeat: ":studioBeat",
                             rows: ":targetLangs",
                             lang: ":lang.text",
+                            studio: ":studio",
                         },
                         params: {
                             compositeResult: true,
@@ -60,6 +72,7 @@ const translateGraph = {
                                     inputs: {
                                         targetLang: ":targetLang",
                                         beat: ":beat",
+                                        studioBeat: ":studioBeat",
                                         lang: ":lang",
                                         system: "Please translate the given text into the language specified in language (in locale format, like en, ja, fr, ch).",
                                         prompt: ["## Original Language", ":lang", "", "## Language", ":targetLang", "", "## Target", ":beat.text"],
@@ -138,7 +151,7 @@ const translateGraph = {
                         isResult: true,
                         agent: "mergeObjectAgent",
                         inputs: {
-                            items: [":beat", { multiLingualTexts: ":mergeLocalizedText" }],
+                            items: [":studioBeat", { multiLingualTexts: ":mergeLocalizedText" }],
                         },
                     },
                 },
@@ -156,14 +169,14 @@ const translateGraph = {
 };
 const localizedTextCacheAgentFilter = async (context, next) => {
     const { namedInputs } = context;
-    const { targetLang, beat, lang } = namedInputs;
+    const { targetLang, beat, lang, studioBeat } = namedInputs;
     // The original text is unchanged and the target language text is present
-    if (beat.multiLingualTexts &&
-        beat.multiLingualTexts[lang] &&
-        beat.multiLingualTexts[lang].text === beat.text &&
-        beat.multiLingualTexts[targetLang] &&
-        beat.multiLingualTexts[targetLang].text) {
-        return { text: beat.multiLingualTexts[targetLang].text };
+    if (studioBeat.multiLingualTexts &&
+        studioBeat.multiLingualTexts[lang] &&
+        studioBeat.multiLingualTexts[lang].text === beat.text &&
+        studioBeat.multiLingualTexts[targetLang] &&
+        studioBeat.multiLingualTexts[targetLang].text) {
+        return { text: studioBeat.multiLingualTexts[targetLang].text };
     }
     // same language
     if (targetLang === lang) {

package/lib/agents/combine_audio_files_agent.js

@@ -1,11 +1,10 @@
 import { GraphAILogger } from "graphai";
 import ffmpeg from "fluent-ffmpeg";
-import { silentPath, silentLastPath, getAudioSegmentFilePath } from "../utils/file.js";
-import { MulmoStudioContextMethods } from "../methods/index.js";
+import { silentPath, silentLastPath } from "../utils/file.js";
 const combineAudioFilesAgent = async ({ namedInputs }) => {
     const { context, combinedFileName, audioDirPath } = namedInputs;
     const command = ffmpeg();
-    const getDuration = (filePath, isLast) => {
+    const getDuration = (filePath, isLastGap) => {
         return new Promise((resolve, reject) => {
             ffmpeg.ffprobe(filePath, (err, metadata) => {
                 if (err) {
@@ -13,30 +12,22 @@ const combineAudioFilesAgent = async ({ namedInputs }) => {
                     reject(err);
                 }
                 else {
-                    resolve(metadata.format.duration + (isLast ? 0.8 : 0.3));
+                    // TODO: Remove hard-coded 0.8 and 0.3
+                    resolve(metadata.format.duration + (isLastGap ? 0.8 : 0.3));
                 }
             });
         });
     };
-    const resolveAudioFilePath = (context, mulmoBeat, audioDirPath) => {
-        if (mulmoBeat.audio?.type === "audio") {
-            const { source } = mulmoBeat.audio;
-            if (source.kind === "path") {
-                return MulmoStudioContextMethods.resolveAssetPath(context, source.path);
-            }
-            if (source.kind === "url") {
-                return source.url;
-            }
+    await Promise.all(context.studio.beats.map(async (studioBeat, index) => {
+        const isLastGap = index === context.studio.beats.length - 2;
+        if (studioBeat.audioFile) {
+            command.input(studioBeat.audioFile);
+            command.input(isLastGap ? silentLastPath : silentPath);
+            studioBeat.duration = await getDuration(studioBeat.audioFile, isLastGap);
+        }
+        else {
+            GraphAILogger.error("Missing studioBeat.audioFile:", index);
         }
-        return getAudioSegmentFilePath(audioDirPath, context.studio.filename, mulmoBeat.audioFile ?? "");
-    };
-    await Promise.all(context.studio.beats.map(async (mulmoBeat, index) => {
-        const filePath = resolveAudioFilePath(context, mulmoBeat, audioDirPath);
-        const isLast = index === context.studio.beats.length - 2;
-        command.input(filePath);
-        command.input(isLast ? silentLastPath : silentPath);
-        // Measure and log the timestamp of each section
-        context.studio.beats[index]["duration"] = await getDuration(filePath, isLast);
     }));
     await new Promise((resolve, reject) => {
         command

package/lib/cli/args.d.ts

@@ -1,4 +1,4 @@
-export declare const args: {
+export declare const getArgs: () => {
     [x: string]: unknown;
     v: boolean;
     o: string | undefined;
@@ -6,6 +6,8 @@ export declare const args: {
     a: string | undefined;
     i: string | undefined;
     f: boolean;
+    pdf_mode: string;
+    pdf_size: string;
     _: (string | number)[];
     $0: string;
 };

package/lib/cli/args.js

@@ -1,40 +1,55 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { commonOptions } from "./common.js";
-export const args = commonOptions(yargs(hideBin(process.argv)))
-    .scriptName("mulmo")
-    .option("a", {
-    alias: "audiodir",
-    description: "audio dir",
-    demandOption: false,
-    type: "string",
-})
-    .option("i", {
-    alias: "imagedir",
-    description: "image dir",
-    demandOption: false,
-    type: "string",
-})
-    .option("f", {
-    alias: "force",
-    description: "force generate",
-    demandOption: false,
-    default: false,
-    type: "boolean",
-})
-    .command("$0 <action> <file>", "Run mulmocast", (yargs) => {
-    return yargs
-        .positional("action", {
-        describe: "action to perform",
-        choices: ["translate", "audio", "images", "movie", "preprocess"],
+import { pdf_modes, pdf_sizes } from "../utils/const.js";
+export const getArgs = () => {
+    return commonOptions(yargs(hideBin(process.argv)))
+        .scriptName("mulmo")
+        .option("a", {
+        alias: "audiodir",
+        description: "audio dir",
+        demandOption: false,
         type: "string",
     })
-        .positional("file", {
-        describe: "Mulmo Script File",
+        .option("i", {
+        alias: "imagedir",
+        description: "image dir",
+        demandOption: false,
         type: "string",
-    });
-})
-    .strict()
-    .help()
-    .alias("help", "h")
-    .parseSync();
+    })
+        .option("f", {
+        alias: "force",
+        description: "force generate",
+        demandOption: false,
+        default: false,
+        type: "boolean",
+    })
+        .option("pdf_mode", {
+        description: "pdf mode",
+        demandOption: false,
+        choices: pdf_modes,
+        type: "string",
+        default: "slide",
+    })
+        .option("pdf_size", {
+        choices: pdf_sizes,
+        default: "letter",
+        describe: "PDF paper size (default: letter for US standard)",
+    })
+        .command("$0 <action> <file>", "Run mulmocast", (yargs) => {
+        return yargs
+            .positional("action", {
+            describe: "action to perform",
+            choices: ["translate", "audio", "images", "movie", "pdf", "preprocess"],
+            type: "string",
+        })
+            .positional("file", {
+            describe: "Mulmo Script File",
+            type: "string",
+        });
+    })
+        .strict()
+        .help()
+        .alias("help", "h")
+        .parseSync();
+};

package/lib/cli/cli.d.ts

@@ -1,2 +1,17 @@
 #!/usr/bin/env node
 import "dotenv/config";
+export declare const getFileObject: (_args: {
+    [x: string]: unknown;
+}) => {
+    baseDirPath: string;
+    mulmoFilePath: string;
+    mulmoFileDirPath: string;
+    outDirPath: string;
+    imageDirPath: string;
+    audioDirPath: string;
+    isHttpPath: boolean;
+    fileOrUrl: string;
+    outputStudioFilePath: string;
+    fileName: string;
+};
+export declare const main: () => Promise<void>;