mulmocast 0.0.25 → 0.0.27

package/README.md

@@ -173,7 +173,7 @@ DEFAULT_OPENAI_IMAGE_MODEL=gpt-image-1 # required for high-quality Ghibli-style
 
 ### Step 2: Generate a Ghibli-style MulmoScript
 ```bash
-mulmo tool scripting -i -t ghibli_strips -o ./ -s story
+mulmo tool scripting -i -t ghibli_comic -o ./ -s story
 ```
 This will initiate an interactive conversation with the AI to create your Ghibli-inspired story. Once completed, a JSON file (e.g., `story-1747834931950.json`) will be generated.
 

package/lib/actions/audio.js

@@ -32,7 +32,7 @@ const getAudioPath = (context, beat, audioFile) => {
         }
         throw new Error("Invalid audio source");
     }
-    if (beat.text === undefined || beat.text === "") {
+    if (beat.text === undefined || beat.text === "" || context.studio.script.audioParams.suppressSpeech) {
         return undefined; // It indicates that the audio is not needed.
     }
     return audioFile;

package/lib/actions/images.js

@@ -372,13 +372,11 @@ const prepareGenerateImages = async (context) => {
     const imageProjectDirPath = MulmoStudioContextMethods.getImageProjectDirPath(context);
     const outDirPath = MulmoStudioContextMethods.getOutDirPath(context);
     mkdir(imageProjectDirPath);
-    const imageAgentInfo = MulmoPresentationStyleMethods.getImageAgentInfo(context.presentationStyle, context.dryRun);
+    const imageAgentInfo = MulmoPresentationStyleMethods.getImageAgentInfo(context.presentationStyle);
     const htmlImageAgentInfo = MulmoPresentationStyleMethods.getHtmlImageAgentInfo(context.presentationStyle);
     const imageRefs = await getImageRefs(context);
     // Determine movie agent based on provider
     const getMovieAgent = () => {
-        if (context.dryRun)
-            return "mediaMockAgent";
         const provider = context.presentationStyle.movieParams?.provider ?? "google";
         switch (provider) {
             case "replicate":

package/lib/cli/commands/audio/builder.d.ts

@@ -7,8 +7,6 @@ export declare const builder: (yargs: Argv) => Argv<{
     l: string | undefined;
 } & {
     f: boolean;
-} & {
-    dryRun: boolean;
 } & {
     p: string | undefined;
 } & {

package/lib/cli/commands/image/builder.d.ts

@@ -7,8 +7,6 @@ export declare const builder: (yargs: Argv) => Argv<{
     l: string | undefined;
 } & {
     f: boolean;
-} & {
-    dryRun: boolean;
 } & {
     p: string | undefined;
 } & {

package/lib/cli/commands/movie/builder.d.ts

@@ -7,8 +7,6 @@ export declare const builder: (yargs: Argv) => Argv<{
     l: string | undefined;
 } & {
     f: boolean;
-} & {
-    dryRun: boolean;
 } & {
     p: string | undefined;
 } & {

package/lib/cli/commands/pdf/builder.d.ts

@@ -7,8 +7,6 @@ export declare const builder: (yargs: Argv) => Argv<{
     l: string | undefined;
 } & {
     f: boolean;
-} & {
-    dryRun: boolean;
 } & {
     p: string | undefined;
 } & {

package/lib/cli/commands/translate/builder.d.ts

@@ -7,8 +7,6 @@ export declare const builder: (yargs: Argv) => Argv<import("yargs").Omit<{
     l: string | undefined;
 } & {
     f: boolean;
-} & {
-    dryRun: boolean;
 } & {
     p: string | undefined;
 } & {

package/lib/cli/common.d.ts

@@ -7,8 +7,6 @@ export declare const commonOptions: (yargs: Argv) => Argv<{
     l: string | undefined;
 } & {
     f: boolean;
-} & {
-    dryRun: boolean;
 } & {
     p: string | undefined;
 } & {

package/lib/cli/common.js

@@ -25,11 +25,6 @@ export const commonOptions = (yargs) => {
         describe: "Force regenerate",
         type: "boolean",
         default: false,
-    })
-        .option("dryRun", {
-        describe: "Dry run",
-        type: "boolean",
-        default: false,
     })
         .option("p", {
         alias: "presentationStyle",

package/lib/cli/helpers.d.ts

@@ -1,20 +1,10 @@
-import type { MulmoScript, MulmoStudioContext, MulmoPresentationStyle, MulmoStudioMultiLingual } from "../types/type.js";
 import type { CliArgs } from "../types/cli_types.js";
+import { FileObject, InitOptions, MulmoStudioContext } from "../types/index.js";
+export declare const runTranslateIfNeeded: (context: MulmoStudioContext, argv: {
+    l?: string;
+    c?: string;
+}) => Promise<void>;
 export declare const setGraphAILogger: (verbose: boolean | undefined, logValues?: Record<string, unknown>) => void;
-export interface FileObject {
-    baseDirPath: string;
-    mulmoFilePath: string;
-    mulmoFileDirPath: string;
-    outDirPath: string;
-    imageDirPath: string;
-    audioDirPath: string;
-    isHttpPath: boolean;
-    fileOrUrl: string;
-    outputStudioFilePath: string;
-    outputMultilingualFilePath: string;
-    presentationStylePath: string | undefined;
-    fileName: string;
-}
 export declare const getFileObject: (args: {
     basedir?: string;
     outdir?: string;
@@ -23,22 +13,4 @@ export declare const getFileObject: (args: {
     presentationStyle?: string;
     file: string;
 }) => FileObject;
-export declare const fetchScript: (isHttpPath: boolean, mulmoFilePath: string, fileOrUrl: string) => Promise<MulmoScript | null>;
-export declare const getMultiLingual: (multilingualFilePath: string, beatsLength: number) => MulmoStudioMultiLingual;
-export declare const getPresentationStyle: (presentationStylePath: string | undefined) => MulmoPresentationStyle | null;
-type InitOptions = {
-    b?: string;
-    o?: string;
-    i?: string;
-    a?: string;
-    file?: string;
-    l?: string;
-    c?: string;
-    p?: string;
-};
-export declare const initializeContext: (argv: CliArgs<InitOptions>) => Promise<MulmoStudioContext | null>;
-export declare const runTranslateIfNeeded: (context: MulmoStudioContext, argv: {
-    l?: string;
-    c?: string;
-}) => Promise<void>;
-export {};
+export declare const initializeContext: (argv: CliArgs<InitOptions>, raiseError?: boolean) => Promise<MulmoStudioContext | null>;

package/lib/cli/helpers.js

@@ -2,12 +2,17 @@ import { GraphAILogger } from "graphai";
 import fs from "fs";
 import path from "path";
 import clipboardy from "clipboardy";
-import { getBaseDirPath, getFullPath, readMulmoScriptFile, fetchMulmoScriptFile, getOutputStudioFilePath, resolveDirPath, mkdir, getOutputMultilingualFilePath, } from "../utils/file.js";
+import { getBaseDirPath, getFullPath, getOutputStudioFilePath, resolveDirPath, mkdir, getOutputMultilingualFilePath, generateTimestampedFileName, } from "../utils/file.js";
 import { isHttp } from "../utils/utils.js";
-import { createOrUpdateStudioData } from "../utils/preprocess.js";
 import { outDirName, imageDirName, audioDirName } from "../utils/const.js";
 import { translate } from "../actions/translate.js";
-import { mulmoCaptionParamsSchema, mulmoPresentationStyleSchema, mulmoStudioMultiLingualSchema } from "../types/schema.js";
+import { initializeContextFromFiles } from "../utils/context.js";
+export const runTranslateIfNeeded = async (context, argv) => {
+    if (argv.l || context.studio.script.captionParams?.lang) {
+        GraphAILogger.log("run translate");
+        await translate(context);
+    }
+};
 export const setGraphAILogger = (verbose, logValues) => {
     if (verbose) {
         if (logValues) {
@@ -29,9 +34,7 @@ export const getFileObject = (args) => {
     const { fileOrUrl, fileName } = (() => {
         if (file === "__clipboard") {
             // We generate a new unique script file from clipboard text in the output directory
-            const now = new Date();
-            const pad = (n) => n.toString().padStart(2, "0");
-            const fileName = `script_${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}_${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+            const fileName = generateTimestampedFileName("script");
             const clipboardText = clipboardy.readSync();
             const fileOrUrl = resolveDirPath(outDirPath, `${fileName}.json`);
             mkdir(outDirPath);
@@ -65,44 +68,7 @@ export const getFileObject = (args) => {
         fileName,
     };
 };
-export const fetchScript = async (isHttpPath, mulmoFilePath, fileOrUrl) => {
-    if (isHttpPath) {
-        const res = await fetchMulmoScriptFile(fileOrUrl);
-        if (!res.result || !res.script) {
-            GraphAILogger.info(`ERROR: HTTP error! ${res.status} ${fileOrUrl}`);
-            return null;
-        }
-        return res.script;
-    }
-    if (!fs.existsSync(mulmoFilePath)) {
-        GraphAILogger.info(`ERROR: File not exists ${mulmoFilePath}`);
-        return null;
-    }
-    return readMulmoScriptFile(mulmoFilePath, "ERROR: File does not exist " + mulmoFilePath)?.mulmoData ?? null;
-};
-export const getMultiLingual = (multilingualFilePath, beatsLength) => {
-    if (fs.existsSync(multilingualFilePath)) {
-        const jsonData = readMulmoScriptFile(multilingualFilePath, "ERROR: File does not exist " + multilingualFilePath)?.mulmoData ?? null;
-        const dataSet = mulmoStudioMultiLingualSchema.parse(jsonData);
-        while (dataSet.length < beatsLength) {
-            dataSet.push({ multiLingualTexts: {} });
-        }
-        dataSet.length = beatsLength;
-        return dataSet;
-    }
-    return [...Array(beatsLength)].map(() => ({ multiLingualTexts: {} }));
-};
-export const getPresentationStyle = (presentationStylePath) => {
-    if (presentationStylePath) {
-        if (!fs.existsSync(presentationStylePath)) {
-            throw new Error(`ERROR: File not exists ${presentationStylePath}`);
-        }
-        const jsonData = readMulmoScriptFile(presentationStylePath, "ERROR: File does not exist " + presentationStylePath)?.mulmoData ?? null;
-        return mulmoPresentationStyleSchema.parse(jsonData);
-    }
-    return null;
-};
-export const initializeContext = async (argv) => {
+export const initializeContext = async (argv, raiseError = false) => {
     const files = getFileObject({
         basedir: argv.b,
         outdir: argv.o,
@@ -111,62 +77,6 @@ export const initializeContext = async (argv) => {
         presentationStyle: argv.p,
         file: argv.file ?? "",
     });
-    const { fileName, isHttpPath, fileOrUrl, mulmoFilePath, outputStudioFilePath, presentationStylePath, outputMultilingualFilePath } = files;
-    setGraphAILogger(argv.v, {
-        files,
-    });
-    const mulmoScript = await fetchScript(isHttpPath, mulmoFilePath, fileOrUrl);
-    if (!mulmoScript) {
-        return null;
-    }
-    const presentationStyle = getPresentationStyle(presentationStylePath);
-    // Create or update MulmoStudio file with MulmoScript
-    const currentStudio = readMulmoScriptFile(outputStudioFilePath);
-    try {
-        // validate mulmoStudioSchema. skip if __test_invalid__ is true
-        const studio = createOrUpdateStudioData(mulmoScript, currentStudio?.mulmoData, fileName);
-        const multiLingual = getMultiLingual(outputMultilingualFilePath, studio.beats.length);
-        if (argv.c) {
-            studio.script.captionParams = mulmoCaptionParamsSchema.parse({
-                ...(studio.script.captionParams ?? {}),
-                lang: argv.c,
-            });
-        }
-        return {
-            studio,
-            fileDirs: files,
-            force: Boolean(argv.f),
-            dryRun: Boolean(argv.dryRun),
-            lang: argv.l,
-            sessionState: {
-                inSession: {
-                    audio: false,
-                    image: false,
-                    video: false,
-                    multiLingual: false,
-                    caption: false,
-                    pdf: false,
-                },
-                inBeatSession: {
-                    audio: {},
-                    image: {},
-                    movie: {},
-                    multiLingual: {},
-                    caption: {},
-                },
-            },
-            presentationStyle: presentationStyle ?? studio.script,
-            multiLingual,
-        };
-    }
-    catch (error) {
-        GraphAILogger.info(`Error: invalid MulmoScript Schema: ${isHttpPath ? fileOrUrl : mulmoFilePath} \n ${error}`);
-        return null;
-    }
-};
-export const runTranslateIfNeeded = async (context, argv) => {
-    if (argv.l || context.studio.script.captionParams?.lang) {
-        GraphAILogger.log("run translate");
-        await translate(context);
-    }
+    setGraphAILogger(Boolean(argv.v), { files });
+    return await initializeContextFromFiles(files, raiseError, Boolean(argv.f), argv.c, argv.l);
 };

package/lib/mcp/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/lib/mcp/server.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { GraphAILogger } from "graphai";
+import { audio, images, movie, captions, pdf } from "../actions/index.js";
+import { initializeContext, runTranslateIfNeeded } from "../cli/helpers.js";
+import { outDirName } from "../utils/const.js";
+import { resolveDirPath, mkdir, generateTimestampedFileName } from "../utils/file.js";
+import { mulmoScriptSchema } from "../types/schema.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Load MulmoScript JSON Schema from file
+const MULMO_SCRIPT_JSON_SCHEMA = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../../assets/schemas/html_prompt.json"), "utf8"));
+const server = new Server({
+    name: "mulmocast-mcp",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Helper function to save MulmoScript content to output directory
+const saveMulmoScriptToOutput = async (mulmoScript) => {
+    const baseDirPath = process.cwd();
+    const outputDirPath = path.resolve(baseDirPath, outDirName);
+    // Create timestamp-based filename similar to __clipboard handling
+    const fileName = generateTimestampedFileName("mcp_script");
+    // Ensure output directory exists
+    mkdir(outputDirPath);
+    // Save MulmoScript to file
+    const filePath = resolveDirPath(outputDirPath, `${fileName}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(mulmoScript, null, 2), "utf8");
+    return filePath;
+};
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "generate",
+                description: "Generate movie or PDF from MulmoScript content",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cmd: {
+                            type: "string",
+                            enum: ["movie", "pdf"],
+                            description: "Command to execute: 'movie' to generate video, 'pdf' to generate PDF",
+                        },
+                        mulmoScript: MULMO_SCRIPT_JSON_SCHEMA,
+                        options: {
+                            type: "object",
+                            description: "Optional generation parameters",
+                            properties: {
+                                pdfMode: { type: "string", enum: ["slide", "talk", "handout"], description: "PDF generation mode (for PDF only)" },
+                                pdfSize: { type: "string", enum: ["A4", "Letter", "Legal"], description: "PDF page size (for PDF only)" },
+                                lang: { type: "string", description: "Language for translation" },
+                                caption: { type: "string", description: "Caption language" },
+                                force: { type: "boolean", description: "Force regeneration" },
+                                verbose: { type: "boolean", description: "Enable verbose logging" },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                    required: ["cmd", "mulmoScript"],
+                    additionalProperties: false,
+                },
+            },
+        ],
+    };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        if (name !== "generate") {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        const { cmd, mulmoScript, options = {}, } = args;
+        // Validate MulmoScript schema
+        const validatedScript = mulmoScriptSchema.parse(mulmoScript);
+        // Save MulmoScript to output directory
+        const filePath = await saveMulmoScriptToOutput(validatedScript);
+        // Create argv-like object for CLI compatibility
+        const argv = {
+            file: filePath,
+            l: options.lang,
+            c: options.caption,
+            f: options.force || false,
+            v: options.verbose || false,
+            pdf_mode: options.pdfMode || "handout",
+            pdf_size: options.pdfSize || "Letter",
+            _: [],
+            $0: "mcp-server",
+        };
+        // Initialize context using the saved file
+        const context = await initializeContext(argv);
+        if (!context) {
+            throw new Error("Failed to initialize context from MulmoScript");
+        }
+        // Run translation if needed
+        await runTranslateIfNeeded(context, argv);
+        // Execute the requested command
+        switch (cmd) {
+            case "movie":
+                // Generate movie (audio + images + captions + movie)
+                await audio(context).then(images).then(captions).then(movie);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Movie generated successfully from MulmoScript. Output saved to: ${context.fileDirs.outDirPath}`,
+                        },
+                    ],
+                };
+            case "pdf":
+                // Generate images first, then PDF
+                await images(context);
+                await pdf(context, options.pdfMode || "handout", options.pdfSize || "Letter");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `PDF generated successfully from MulmoScript. Output saved to: ${context.fileDirs.outDirPath}`,
+                        },
+                    ],
+                };
+            default:
+                throw new Error(`Unknown command: ${cmd}. Supported commands: movie, pdf`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    GraphAILogger.error("MulmoCast MCP Server running on stdio");
+}
+main().catch((error) => {
+    GraphAILogger.error("Failed to start MCP server:", error);
+    process.exit(1);
+});

package/lib/methods/mulmo_presentation_style.d.ts

@@ -9,7 +9,7 @@ export declare const MulmoPresentationStyleMethods: {
     getSpeaker(presentationStyle: MulmoPresentationStyle, beat: MulmoBeat): SpeakerData;
     getProvider(presentationStyle: MulmoPresentationStyle, beat: MulmoBeat): Text2SpeechProvider;
     getVoiceId(presentationStyle: MulmoPresentationStyle, beat: MulmoBeat): string;
-    getImageAgentInfo(presentationStyle: MulmoPresentationStyle, dryRun?: boolean): Text2ImageAgentInfo;
+    getImageAgentInfo(presentationStyle: MulmoPresentationStyle): Text2ImageAgentInfo;
     getHtmlImageAgentInfo(presentationStyle: MulmoPresentationStyle): Text2HtmlAgentInfo;
     getImageType(_: MulmoPresentationStyle, beat: MulmoBeat): BeatMediaType;
 };

package/lib/methods/mulmo_presentation_style.js

@@ -57,7 +57,7 @@ export const MulmoPresentationStyleMethods = {
         const speaker = MulmoPresentationStyleMethods.getSpeaker(presentationStyle, beat);
         return speaker.voiceId;
     },
-    getImageAgentInfo(presentationStyle, dryRun = false) {
+    getImageAgentInfo(presentationStyle) {
         // Notice that we copy imageParams from presentationStyle and update
         // provider and model appropriately.
         const provider = text2ImageProviderSchema.parse(presentationStyle.imageParams?.provider);
@@ -66,7 +66,7 @@ export const MulmoPresentationStyleMethods = {
         };
         return {
             provider,
-            agent: dryRun ? "mediaMockAgent" : provider === "google" ? "imageGoogleAgent" : "imageOpenaiAgent",
+            agent: provider === "google" ? "imageGoogleAgent" : "imageOpenaiAgent",
             imageParams: { ...defaultImageParams, ...presentationStyle.imageParams },
         };
     },