mulmocast 0.0.5 → 0.0.7

package/lib/actions/translate.js

@@ -5,6 +5,8 @@ import { openAIAgent } from "@graphai/openai_agent";
 import { fileWriteAgent } from "@graphai/vanilla_node_agents";
 import { recursiveSplitJa, replacementsJa, replacePairsJa } from "../utils/string.js";
 import { getOutputStudioFilePath, mkdir, writingMessage } from "../utils/file.js";
+import { translateSystemPrompt, translatePrompts } from "../utils/prompt.js";
+import { MulmoStudioMethods } from "../methods/mulmo_studio.js";
 const { default: __, ...vanillaAgents } = agents;
 const translateGraph = {
     version: 0.5,
@@ -25,7 +27,7 @@ const translateGraph = {
             isResult: true,
             agent: "mergeObjectAgent",
             inputs: {
-                items: [":studio", { beats: ":beatsMap.mergeBeatData" }],
+                items: [":studio", { multiLingual: ":beatsMap.mergeMultiLingualData" }],
             },
         },
         beatsMap: {
@@ -43,23 +45,25 @@ const translateGraph = {
             graph: {
                 version: 0.5,
                 nodes: {
-                    studioBeat: {
+                    // for cache
+                    multiLingual: {
                         agent: (namedInputs) => {
-                            return namedInputs.rows[namedInputs.index];
+                            return (namedInputs.rows && namedInputs.rows[namedInputs.index]) || {};
                         },
                         inputs: {
                             index: ":__mapIndex",
-                            rows: ":studio.beats",
+                            rows: ":studio.multiLingual",
                         },
                     },
-                    preprocessBeats: {
+                    preprocessMultiLingual: {
                         agent: "mapAgent",
                         inputs: {
                             beat: ":beat",
-                            studioBeat: ":studioBeat",
+                            multiLingual: ":multiLingual",
                             rows: ":targetLangs",
                             lang: ":lang.text",
                             studio: ":studio",
+                            beatIndex: ":__mapIndex",
                         },
                         params: {
                             compositeResult: true,
@@ -70,12 +74,14 @@ const translateGraph = {
                             nodes: {
                                 localizedTexts: {
                                     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"],
+                                        targetLang: ":targetLang", // for cache
+                                        beat: ":beat", // for cache
+                                        multiLingual: ":multiLingual", // for cache
+                                        lang: ":lang", // for cache
+                                        beatIndex: ":beatIndex", // for cache
+                                        studio: ":studio", // for cache
+                                        system: translateSystemPrompt,
+                                        prompt: translatePrompts,
                                     },
                                     passThrough: {
                                         lang: ":targetLang",
@@ -141,17 +147,17 @@ const translateGraph = {
                     mergeLocalizedText: {
                         agent: "arrayToObjectAgent",
                         inputs: {
-                            items: ":preprocessBeats.ttsTexts",
+                            items: ":preprocessMultiLingual.ttsTexts",
                         },
                         params: {
                             key: "lang",
                         },
                     },
-                    mergeBeatData: {
+                    mergeMultiLingualData: {
                         isResult: true,
                         agent: "mergeObjectAgent",
                         inputs: {
-                            items: [":studioBeat", { multiLingualTexts: ":mergeLocalizedText" }],
+                            items: [":multiLingual", { multiLingualTexts: ":mergeLocalizedText" }],
                         },
                     },
                 },
@@ -169,20 +175,29 @@ const translateGraph = {
 };
 const localizedTextCacheAgentFilter = async (context, next) => {
     const { namedInputs } = context;
-    const { targetLang, beat, lang, studioBeat } = namedInputs;
+    const { studio, targetLang, beat, beatIndex, lang, multiLingual } = namedInputs;
+    if (!beat.text) {
+        return { text: "" };
+    }
     // The original text is unchanged and the target language text is present
-    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 };
+    if (multiLingual.multiLingualTexts &&
+        multiLingual.multiLingualTexts[lang] &&
+        multiLingual.multiLingualTexts[lang].text === beat.text &&
+        multiLingual.multiLingualTexts[targetLang] &&
+        multiLingual.multiLingualTexts[targetLang].text) {
+        return { text: multiLingual.multiLingualTexts[targetLang].text };
     }
     // same language
     if (targetLang === lang) {
         return { text: beat.text };
     }
-    return await next(context);
+    try {
+        MulmoStudioMethods.setBeatSessionState(studio, "multiLingual", beatIndex, true);
+        return await next(context);
+    }
+    finally {
+        MulmoStudioMethods.setBeatSessionState(studio, "multiLingual", beatIndex, false);
+    }
 };
 const agentFilters = [
     {
@@ -194,20 +209,26 @@ const agentFilters = [
 const defaultLang = "en";
 const targetLangs = ["ja", "en"];
 export const translate = async (context) => {
-    const { studio, fileDirs } = context;
-    const { outDirPath } = fileDirs;
-    const outputStudioFilePath = getOutputStudioFilePath(outDirPath, studio.filename);
-    mkdir(outDirPath);
-    assert(!!process.env.OPENAI_API_KEY, "The OPENAI_API_KEY environment variable is missing or empty");
-    const graph = new GraphAI(translateGraph, { ...vanillaAgents, fileWriteAgent, openAIAgent }, { agentFilters });
-    graph.injectValue("studio", studio);
-    graph.injectValue("defaultLang", defaultLang);
-    graph.injectValue("targetLangs", targetLangs);
-    graph.injectValue("outDirPath", outDirPath);
-    graph.injectValue("outputStudioFilePath", outputStudioFilePath);
-    await graph.run();
-    writingMessage(outputStudioFilePath);
-    // const results = await graph.run();
-    // const mulmoDataResult = results.mergeResult;
-    // console.log(JSON.stringify(mulmoDataResult, null, 2));
+    try {
+        MulmoStudioMethods.setSessionState(context.studio, "multiLingual", true);
+        const { studio, fileDirs } = context;
+        const { outDirPath } = fileDirs;
+        const outputStudioFilePath = getOutputStudioFilePath(outDirPath, studio.filename);
+        mkdir(outDirPath);
+        assert(!!process.env.OPENAI_API_KEY, "The OPENAI_API_KEY environment variable is missing or empty");
+        const graph = new GraphAI(translateGraph, { ...vanillaAgents, fileWriteAgent, openAIAgent }, { agentFilters });
+        graph.injectValue("studio", studio);
+        graph.injectValue("defaultLang", defaultLang);
+        graph.injectValue("targetLangs", targetLangs);
+        graph.injectValue("outDirPath", outDirPath);
+        graph.injectValue("outputStudioFilePath", outputStudioFilePath);
+        const results = await graph.run();
+        writingMessage(outputStudioFilePath);
+        if (results.mergeStudioResult) {
+            context.studio = results.mergeStudioResult;
+        }
+    }
+    finally {
+        MulmoStudioMethods.setSessionState(context.studio, "multiLingual", false);
+    }
 };

package/lib/agents/add_bgm_agent.js

@@ -1,46 +1,22 @@
 import { GraphAILogger } from "graphai";
-import ffmpeg from "fluent-ffmpeg";
-import { MulmoScriptMethods } from "../methods/index.js";
+import { FfmpegContextAddInput, FfmpegContextInit, FfmpegContextGenerateOutput, ffmpegGetMediaDuration } from "../utils/ffmpeg_utils.js";
 const addBGMAgent = async ({ namedInputs, params, }) => {
     const { voiceFile, outputFile, script } = namedInputs;
     const { musicFile } = params;
-    const promise = new Promise((resolve, reject) => {
-        ffmpeg.ffprobe(voiceFile, (err, metadata) => {
-            if (err) {
-                GraphAILogger.info("Error getting metadata: " + err.message);
-                reject(err);
-            }
-            const speechDuration = metadata.format.duration;
-            const padding = MulmoScriptMethods.getPadding(script);
-            const totalDuration = (padding * 2) / 1000 + Math.round(speechDuration ?? 0);
-            GraphAILogger.log("totalDucation:", speechDuration, totalDuration);
-            const command = ffmpeg();
-            command
-                .input(musicFile)
-                .input(voiceFile)
-                .complexFilter([
-                // Add a 2-second delay to the speech
-                `[1:a]adelay=${padding}|${padding}, volume=4[a1]`, // 4000ms delay for both left and right channels
-                // Set the background music volume to 0.2
-                `[0:a]volume=0.2[a0]`,
-                // Mix the delayed speech and the background music
-                `[a0][a1]amix=inputs=2:duration=longest:dropout_transition=3[amixed]`,
-                // Trim the output to the length of speech + 8 seconds
-                `[amixed]atrim=start=0:end=${totalDuration}[trimmed]`,
-                // Add fade out effect for the last 4 seconds
-                `[trimmed]afade=t=out:st=${totalDuration - padding / 1000}:d=${padding}`,
-            ])
-                .on("error", (err) => {
-                GraphAILogger.info("Error: " + err.message);
-                reject(err);
-            })
-                .on("end", () => {
-                resolve(0);
-            })
-                .save(outputFile);
-        });
-    });
-    await promise;
+    const speechDuration = await ffmpegGetMediaDuration(voiceFile);
+    const introPadding = script.audioParams.introPadding;
+    const outroPadding = script.audioParams.outroPadding;
+    const totalDuration = speechDuration + introPadding + outroPadding;
+    GraphAILogger.log("totalDucation:", speechDuration, totalDuration);
+    const ffmpegContext = FfmpegContextInit();
+    const musicInputIndex = FfmpegContextAddInput(ffmpegContext, musicFile);
+    const voiceInputIndex = FfmpegContextAddInput(ffmpegContext, voiceFile);
+    ffmpegContext.filterComplex.push(`[${musicInputIndex}:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo, volume=0.2[music]`);
+    ffmpegContext.filterComplex.push(`[${voiceInputIndex}:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo, volume=2, adelay=${introPadding * 1000}|${introPadding * 1000}[voice]`);
+    ffmpegContext.filterComplex.push(`[music][voice]amix=inputs=2:duration=longest[mixed]`);
+    ffmpegContext.filterComplex.push(`[mixed]atrim=start=0:end=${totalDuration}[trimmed]`);
+    ffmpegContext.filterComplex.push(`[trimmed]afade=t=out:st=${totalDuration - outroPadding}:d=${outroPadding}[faded]`);
+    await FfmpegContextGenerateOutput(ffmpegContext, outputFile, ["-map", "[faded]"]);
     return outputFile;
 };
 const addBGMAgentInfo = {

package/lib/agents/combine_audio_files_agent.js

@@ -1,45 +1,63 @@
 import { GraphAILogger } from "graphai";
-import ffmpeg from "fluent-ffmpeg";
-import { silentPath, silentLastPath } from "../utils/file.js";
-const combineAudioFilesAgent = async ({ namedInputs }) => {
-    const { context, combinedFileName, audioDirPath } = namedInputs;
-    const command = ffmpeg();
-    const getDuration = (filePath, isLastGap) => {
-        return new Promise((resolve, reject) => {
-            ffmpeg.ffprobe(filePath, (err, metadata) => {
-                if (err) {
-                    GraphAILogger.info("Error while getting metadata:", err);
-                    reject(err);
+import { silent60secPath } from "../utils/file.js";
+import { FfmpegContextInit, FfmpegContextGenerateOutput, FfmpegContextInputFormattedAudio, ffmpegGetMediaDuration } from "../utils/ffmpeg_utils.js";
+const combineAudioFilesAgent = async ({ namedInputs, }) => {
+    const { context, combinedFileName } = namedInputs;
+    const ffmpegContext = FfmpegContextInit();
+    const longSilentId = FfmpegContextInputFormattedAudio(ffmpegContext, silent60secPath);
+    // We cannot reuse longSilentId. We need to explicitly split it for each beat.
+    const silentIds = context.studio.beats.map((_, index) => `[ls_${index}]`);
+    ffmpegContext.filterComplex.push(`${longSilentId}asplit=${silentIds.length}${silentIds.join("")}`);
+    const inputIds = (await Promise.all(context.studio.beats.map(async (studioBeat, index) => {
+        const beat = context.studio.script.beats[index];
+        const isClosingGap = index === context.studio.beats.length - 2;
+        if (studioBeat.audioFile) {
+            const audioId = FfmpegContextInputFormattedAudio(ffmpegContext, studioBeat.audioFile);
+            const padding = (() => {
+                if (beat.audioParams?.padding !== undefined) {
+                    return beat.audioParams.padding;
                 }
-                else {
-                    // TODO: Remove hard-coded 0.8 and 0.3
-                    resolve(metadata.format.duration + (isLastGap ? 0.8 : 0.3));
+                if (index === context.studio.beats.length - 1) {
+                    return 0;
                 }
-            });
-        });
-    };
-    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);
+                return isClosingGap ? context.studio.script.audioParams.closingPadding : context.studio.script.audioParams.padding;
+            })();
+            const audioDuration = await ffmpegGetMediaDuration(studioBeat.audioFile);
+            const totalPadding = await (async () => {
+                if (beat.image?.type === "movie" && (beat.image.source.kind === "url" || beat.image.source.kind === "path")) {
+                    const pathOrUrl = beat.image.source.kind === "url" ? beat.image.source.url : beat.image.source.path;
+                    const movieDuration = await ffmpegGetMediaDuration(pathOrUrl);
+                    if (movieDuration > audioDuration) {
+                        return padding + (movieDuration - audioDuration);
+                    }
+                }
+                return padding;
+            })();
+            studioBeat.duration = audioDuration + totalPadding;
+            if (totalPadding > 0) {
+                const silentId = silentIds.pop();
+                ffmpegContext.filterComplex.push(`${silentId}atrim=start=0:end=${totalPadding}[padding_${index}]`);
+                return [audioId, `[padding_${index}]`];
+            }
+            else {
+                return [audioId];
+            }
         }
         else {
-            GraphAILogger.error("Missing studioBeat.audioFile:", index);
+            // NOTE: We come here when the text is empty and no audio property is specified.
+            studioBeat.duration = beat.duration ?? 1.0;
+            const silentId = silentIds.pop();
+            ffmpegContext.filterComplex.push(`${silentId}atrim=start=0:end=${studioBeat.duration}[silent_${index}]`);
+            return [`[silent_${index}]`];
         }
-    }));
-    await new Promise((resolve, reject) => {
-        command
-            .on("end", () => {
-            resolve(0);
-        })
-            .on("error", (err) => {
-            GraphAILogger.info("Error while combining MP3 files:", err);
-            reject(err);
-        })
-            .mergeToFile(combinedFileName, audioDirPath);
+    }))).flat();
+    silentIds.forEach((silentId) => {
+        GraphAILogger.log(`Using extra silentId: ${silentId}`);
+        ffmpegContext.filterComplex.push(`${silentId}atrim=start=0:end=${0.01}[silent_extra]`);
+        inputIds.push("[silent_extra]");
     });
+    ffmpegContext.filterComplex.push(`${inputIds.join("")}concat=n=${inputIds.length}:v=0:a=1[aout]`);
+    await FfmpegContextGenerateOutput(ffmpegContext, combinedFileName, ["-map", "[aout]"]);
     return {
         studio: context.studio,
     };

package/lib/agents/index.d.ts

@@ -2,12 +2,11 @@ import addBGMAgent from "./add_bgm_agent.js";
 import combineAudioFilesAgent from "./combine_audio_files_agent.js";
 import imageGoogleAgent from "./image_google_agent.js";
 import imageOpenaiAgent from "./image_openai_agent.js";
-import mulmoPromptsAgent from "./mulmo_prompts_agent.js";
 import ttsNijivoiceAgent from "./tts_nijivoice_agent.js";
 import ttsOpenaiAgent from "./tts_openai_agent.js";
-import validateMulmoScriptAgent from "./validate_mulmo_script_agent.js";
+import validateSchemaAgent from "./validate_schema_agent.js";
 import { browserlessAgent } from "@graphai/browserless_agent";
 import { textInputAgent } from "@graphai/input_agents";
 import { openAIAgent } from "@graphai/openai_agent";
 import { fileWriteAgent } from "@graphai/vanilla_node_agents";
-export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, mulmoPromptsAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateMulmoScriptAgent, };
+export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateSchemaAgent, };

package/lib/agents/index.js

@@ -2,13 +2,12 @@ import addBGMAgent from "./add_bgm_agent.js";
 import combineAudioFilesAgent from "./combine_audio_files_agent.js";
 import imageGoogleAgent from "./image_google_agent.js";
 import imageOpenaiAgent from "./image_openai_agent.js";
-import mulmoPromptsAgent from "./mulmo_prompts_agent.js";
 import ttsNijivoiceAgent from "./tts_nijivoice_agent.js";
 import ttsOpenaiAgent from "./tts_openai_agent.js";
-import validateMulmoScriptAgent from "./validate_mulmo_script_agent.js";
+import validateSchemaAgent from "./validate_schema_agent.js";
 import { browserlessAgent } from "@graphai/browserless_agent";
 import { textInputAgent } from "@graphai/input_agents";
 import { openAIAgent } from "@graphai/openai_agent";
 // import * as vanilla from "@graphai/vanilla";
 import { fileWriteAgent } from "@graphai/vanilla_node_agents";
-export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, mulmoPromptsAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateMulmoScriptAgent, };
+export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateSchemaAgent, };

package/lib/agents/tts_google_agent.d.ts

@@ -0,0 +1,4 @@
+import type { AgentFunction, AgentFunctionInfo } from "graphai";
+export declare const ttsGoogleAgent: AgentFunction;
+declare const ttsGoogleAgentInfo: AgentFunctionInfo;
+export default ttsGoogleAgentInfo;

package/lib/agents/tts_google_agent.js

@@ -0,0 +1,51 @@
+import { GraphAILogger } from "graphai";
+import * as textToSpeech from "@google-cloud/text-to-speech";
+const client = new textToSpeech.TextToSpeechClient();
+export const ttsGoogleAgent = async ({ namedInputs, params }) => {
+    const { text } = namedInputs;
+    const { voice, suppressError, speed } = params;
+    // Construct the voice request
+    const voiceParams = {
+        languageCode: "en-US", // TODO: Make this configurable
+        ssmlGender: "FEMALE", // TODO: Make this configurable
+    };
+    if (voice) {
+        voiceParams.name = voice;
+    }
+    // Construct the request
+    const request = {
+        input: { text: text },
+        voice: voiceParams,
+        audioConfig: {
+            audioEncoding: "MP3",
+            speakingRate: speed || 1.0,
+        },
+    };
+    try {
+        // Call the Text-to-Speech API
+        const [response] = await client.synthesizeSpeech(request);
+        return { buffer: response.audioContent };
+    }
+    catch (e) {
+        if (suppressError) {
+            return {
+                error: e,
+            };
+        }
+        GraphAILogger.info(e);
+        throw new Error("TTS Google Error");
+    }
+};
+const ttsGoogleAgentInfo = {
+    name: "ttsGoogleAgent",
+    agent: ttsGoogleAgent,
+    mock: ttsGoogleAgent,
+    samples: [],
+    description: "Google TTS agent",
+    category: ["tts"],
+    author: "Receptron Team",
+    repository: "https://github.com/receptron/graphai-agents/tree/main/tts/tts-openai-agent",
+    license: "MIT",
+    environmentVariables: ["OPENAI_API_KEY"],
+};
+export default ttsGoogleAgentInfo;

package/lib/agents/validate_schema_agent.d.ts

@@ -0,0 +1,19 @@
+import type { AgentFunction, AgentFunctionInfo, DefaultConfigData } from "graphai";
+import { MulmoScript } from "../types/index.js";
+import { ZodSchema } from "zod";
+interface ValidateMulmoScriptInputs {
+    text: string;
+    schema: ZodSchema;
+}
+interface ValidateMulmoScriptResponse {
+    isValid: boolean;
+    data?: MulmoScript;
+    error?: string;
+}
+/**
+ * Zod schema validation agent
+ * Validates if a JSON string conforms to the Zod schema
+ */
+export declare const validateSchemaAgent: AgentFunction<object, ValidateMulmoScriptResponse, ValidateMulmoScriptInputs, DefaultConfigData>;
+declare const validateMulmoScriptAgentInfo: AgentFunctionInfo;
+export default validateMulmoScriptAgentInfo;

package/lib/agents/validate_schema_agent.js

@@ -0,0 +1,36 @@
+import assert from "node:assert";
+/**
+ * Zod schema validation agent
+ * Validates if a JSON string conforms to the Zod schema
+ */
+export const validateSchemaAgent = async ({ namedInputs, }) => {
+    const { text, schema } = namedInputs;
+    try {
+        assert(schema, "schema is required");
+        assert(text, "text is required");
+        const jsonData = JSON.parse(text);
+        const parsed = schema.parse(jsonData);
+        return {
+            isValid: true,
+            data: parsed,
+        };
+    }
+    catch (error) {
+        return {
+            isValid: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+};
+const validateMulmoScriptAgentInfo = {
+    name: "validateSchemaAgent",
+    agent: validateSchemaAgent,
+    mock: validateSchemaAgent,
+    samples: [],
+    description: "Validates if a JSON string conforms to the Zod schema",
+    category: ["validation"],
+    author: "Receptron Team",
+    repository: "https://github.com/receptron/mulmocast-cli/tree/main/src/agents/validate_schema_agent.ts",
+    license: "MIT",
+};
+export default validateMulmoScriptAgentInfo;

package/lib/cli/args.d.ts

@@ -3,9 +3,11 @@ export declare const getArgs: () => {
     v: boolean;
     o: string | undefined;
     b: string | undefined;
+    l: string | undefined;
     a: string | undefined;
     i: string | undefined;
     f: boolean;
+    c: string | undefined;
     pdf_mode: string;
     pdf_size: string;
     _: (string | number)[];

package/lib/cli/args.js

@@ -1,7 +1,7 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { commonOptions } from "./common.js";
-import { pdf_modes, pdf_sizes } from "../utils/const.js";
+import { pdf_modes, pdf_sizes, languages } from "../utils/const.js";
 export const getArgs = () => {
     return commonOptions(yargs(hideBin(process.argv)))
         .scriptName("mulmo")
@@ -23,6 +23,13 @@ export const getArgs = () => {
         demandOption: false,
         default: false,
         type: "boolean",
+    })
+        .option("c", {
+        alias: "caption",
+        description: "Video captions",
+        choices: languages,
+        demandOption: false,
+        type: "string",
     })
         .option("pdf_mode", {
         description: "pdf mode",
@@ -40,7 +47,7 @@ export const getArgs = () => {
         return yargs
             .positional("action", {
             describe: "action to perform",
-            choices: ["translate", "audio", "images", "movie", "pdf", "preprocess"],
+            choices: ["translate", "audio", "images", "movie", "pdf"],
             type: "string",
         })
             .positional("file", {

package/lib/cli/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import "dotenv/config";
+export declare const main: () => Promise<void>;

package/lib/cli/bin.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+import * as translateCmd from "./commands/translate/index.js";
+import * as audioCmd from "./commands/audio/index.js";
+import * as imagesCmd from "./commands/image/index.js";
+import * as movieCmd from "./commands/movie/index.js";
+import * as pdfCmd from "./commands/pdf/index.js";
+import * as toolCmd from "./commands/tool/index.js";
+import { GraphAILogger } from "graphai";
+export const main = async () => {
+    const cli = yargs(hideBin(process.argv))
+        .scriptName("mulmo")
+        .usage("$0 <command> [options]")
+        .option("v", {
+        alias: "verbose",
+        describe: "verbose log",
+        demandOption: true,
+        default: false,
+        type: "boolean",
+    })
+        .command(translateCmd)
+        .command(audioCmd)
+        .command(imagesCmd)
+        .command(movieCmd)
+        .command(pdfCmd)
+        .command(toolCmd)
+        .demandCommand()
+        .strict()
+        .help()
+        .alias("help", "h");
+    await cli.parseAsync();
+};
+main().catch((error) => {
+    GraphAILogger.info("An unexpected error occurred:", error);
+    process.exit(1);
+});